rpc

type AccountGetQuotaResult struct {
	// Quota snapshots keyed by type (e.g., chat, completions, premium_interactions)
	QuotaSnapshots map[string]QuotaSnapshot `json:"quotaSnapshots"`
}

type AgentElement struct {
	// Description of the agent's purpose
	Description string `json:"description"`
	// Human-readable display name
	DisplayName string `json:"displayName"`
	// Unique identifier of the custom agent
	Name string `json:"name"`
}

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

type Billing struct {
	// Billing cost multiplier relative to the base rate
	Multiplier float64 `json:"multiplier"`
}

type Capabilities struct {
	// Token limits for prompts, outputs, and context window
	Limits Limits `json:"limits"`
	// Feature flags indicating what the model supports
	Supports Supports `json:"supports"`
}

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

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

type Kind string

type Level string

type Limits struct {
	// Maximum total context window size in tokens
	MaxContextWindowTokens float64 `json:"max_context_window_tokens"`
	// Maximum number of output/completion tokens
	MaxOutputTokens *float64 `json:"max_output_tokens,omitempty"`
	// Maximum number of prompt/input tokens
	MaxPromptTokens *float64 `json:"max_prompt_tokens,omitempty"`
}

type Mode string

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

type Model struct {
	// Billing information
	Billing *Billing `json:"billing,omitempty"`
	// Model capabilities and limits
	Capabilities Capabilities `json:"capabilities"`
	// Default reasoning effort level (only present if model supports reasoning effort)
	DefaultReasoningEffort *string `json:"defaultReasoningEffort,omitempty"`
	// Model identifier (e.g., "claude-sonnet-4.5")
	ID string `json:"id"`
	// Display name
	Name string `json:"name"`
	// Policy state (if applicable)
	Policy *Policy `json:"policy,omitempty"`
	// Supported reasoning effort levels (only present if model supports reasoning effort)
	SupportedReasoningEfforts []string `json:"supportedReasoningEfforts,omitempty"`
}

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

type ModelsListResult struct {
	// List of available models with full metadata
	Models []Model `json:"models"`
}

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

type PingParams struct {
	// Optional message to echo back
	Message *string `json:"message,omitempty"`
}

type PingResult struct {
	// Echoed message (or default greeting)
	Message string `json:"message"`
	// Server protocol version number
	ProtocolVersion float64 `json:"protocolVersion"`
	// Server timestamp in milliseconds
	Timestamp float64 `json:"timestamp"`
}

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

type Policy struct {
	// Current policy state for this model
	State string `json:"state"`
	// Usage terms or conditions for this model
	Terms string `json:"terms"`
}

type QuotaSnapshot struct {
	// Number of requests included in the entitlement
	EntitlementRequests float64 `json:"entitlementRequests"`
	// Number of overage requests made this period
	Overage float64 `json:"overage"`
	// Whether pay-per-request usage is allowed when quota is exhausted
	OverageAllowedWithExhaustedQuota bool `json:"overageAllowedWithExhaustedQuota"`
	// Percentage of entitlement remaining
	RemainingPercentage float64 `json:"remainingPercentage"`
	// Date when the quota resets (ISO 8601)
	ResetDate *string `json:"resetDate,omitempty"`
	// Number of requests used so far this period
	UsedRequests float64 `json:"usedRequests"`
}

type ResultResult struct {
	Error            *string                `json:"error,omitempty"`
	ResultType       *string                `json:"resultType,omitempty"`
	TextResultForLlm string                 `json:"textResultForLlm"`
	ToolTelemetry    map[string]interface{} `json:"toolTelemetry,omitempty"`
}

type ResultUnion struct {
	ResultResult *ResultResult
	String       *string
}

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

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

type ServerRpc struct {
	Models  *ServerModelsRpcApi
	Tools   *ServerToolsRpcApi
	Account *ServerAccountRpcApi
	// contains filtered or unexported fields
}

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

type SessionAgentDeselectResult struct {
}

type SessionAgentGetCurrentResult struct {
	// Currently selected custom agent, or null if using the default agent
	Agent *SessionAgentGetCurrentResultAgent `json:"agent"`
}

type SessionAgentGetCurrentResultAgent struct {
	// Description of the agent's purpose
	Description string `json:"description"`
	// Human-readable display name
	DisplayName string `json:"displayName"`
	// Unique identifier of the custom agent
	Name string `json:"name"`
}

type SessionAgentListResult struct {
	// Available custom agents
	Agents []AgentElement `json:"agents"`
}

type SessionAgentSelectParams struct {
	// Name of the custom agent to select
	Name string `json:"name"`
}

type SessionAgentSelectResult struct {
	// The newly selected custom agent
	Agent SessionAgentSelectResultAgent `json:"agent"`
}

type SessionAgentSelectResultAgent struct {
	// Description of the agent's purpose
	Description string `json:"description"`
	// Human-readable display name
	DisplayName string `json:"displayName"`
	// Unique identifier of the custom agent
	Name string `json:"name"`
}

type SessionCompactionCompactResult struct {
	// Number of messages removed during compaction
	MessagesRemoved float64 `json:"messagesRemoved"`
	// Whether compaction completed successfully
	Success bool `json:"success"`
	// Number of tokens freed by compaction
	TokensRemoved float64 `json:"tokensRemoved"`
}

type SessionFleetStartParams struct {
	// Optional user prompt to combine with fleet instructions
	Prompt *string `json:"prompt,omitempty"`
}

type SessionFleetStartResult struct {
	// Whether fleet mode was successfully activated
	Started bool `json:"started"`
}

type SessionLogParams struct {
	// When true, the message is transient and not persisted to the session event log on disk
	Ephemeral *bool `json:"ephemeral,omitempty"`
	// Log severity level. Determines how the message is displayed in the timeline. Defaults to
	// "info".
	Level *Level `json:"level,omitempty"`
	// Human-readable message
	Message string `json:"message"`
}

type SessionLogResult struct {
	// The unique identifier of the emitted session event
	EventID string `json:"eventId"`
}

type SessionModeGetResult struct {
	// The current agent mode.
	Mode Mode `json:"mode"`
}

type SessionModeSetParams struct {
	// The mode to switch to. Valid values: "interactive", "plan", "autopilot".
	Mode Mode `json:"mode"`
}

type SessionModeSetResult struct {
	// The agent mode after switching.
	Mode Mode `json:"mode"`
}

type SessionModelGetCurrentResult struct {
	// Currently active model identifier
	ModelID *string `json:"modelId,omitempty"`
}

type SessionModelSwitchToParams struct {
	// Model identifier to switch to
	ModelID string `json:"modelId"`
	// Reasoning effort level to use for the model
	ReasoningEffort *string `json:"reasoningEffort,omitempty"`
}

type SessionModelSwitchToResult struct {
	// Currently active model identifier after the switch
	ModelID *string `json:"modelId,omitempty"`
}

type SessionPermissionsHandlePendingPermissionRequestParams struct {
	RequestID string                                                       `json:"requestId"`
	Result    SessionPermissionsHandlePendingPermissionRequestParamsResult `json:"result"`
}

type SessionPermissionsHandlePendingPermissionRequestParamsResult struct {
	Kind     Kind          `json:"kind"`
	Rules    []interface{} `json:"rules,omitempty"`
	Feedback *string       `json:"feedback,omitempty"`
	Message  *string       `json:"message,omitempty"`
	Path     *string       `json:"path,omitempty"`
}

type SessionPermissionsHandlePendingPermissionRequestResult struct {
	// Whether the permission request was handled successfully
	Success bool `json:"success"`
}

type SessionPlanDeleteResult struct {
}

type SessionPlanReadResult struct {
	// The content of the plan file, or null if it does not exist
	Content *string `json:"content"`
	// Whether the plan file exists in the workspace
	Exists bool `json:"exists"`
	// Absolute file path of the plan file, or null if workspace is not enabled
	Path *string `json:"path"`
}

type SessionPlanUpdateParams struct {
	// The new content for the plan file
	Content string `json:"content"`
}

type SessionPlanUpdateResult struct {
}

type SessionRpc struct {
	Model       *ModelRpcApi
	Mode        *ModeRpcApi
	Plan        *PlanRpcApi
	Workspace   *WorkspaceRpcApi
	Fleet       *FleetRpcApi
	Agent       *AgentRpcApi
	Compaction  *CompactionRpcApi
	Tools       *ToolsRpcApi
	Permissions *PermissionsRpcApi
	Shell       *ShellRpcApi
	// contains filtered or unexported fields
}

type SessionShellExecParams struct {
	// Shell command to execute
	Command string `json:"command"`
	// Working directory (defaults to session working directory)
	Cwd *string `json:"cwd,omitempty"`
	// Timeout in milliseconds (default: 30000)
	Timeout *float64 `json:"timeout,omitempty"`
}

type SessionShellExecResult struct {
	// Unique identifier for tracking streamed output
	ProcessID string `json:"processId"`
}

type SessionShellKillParams struct {
	// Process identifier returned by shell.exec
	ProcessID string `json:"processId"`
	// Signal to send (default: SIGTERM)
	Signal *Signal `json:"signal,omitempty"`
}

type SessionShellKillResult struct {
	// Whether the signal was sent successfully
	Killed bool `json:"killed"`
}

type SessionToolsHandlePendingToolCallParams struct {
	Error     *string      `json:"error,omitempty"`
	RequestID string       `json:"requestId"`
	Result    *ResultUnion `json:"result"`
}

type SessionToolsHandlePendingToolCallResult struct {
	// Whether the tool call result was handled successfully
	Success bool `json:"success"`
}

type SessionWorkspaceCreateFileParams struct {
	// File content to write as a UTF-8 string
	Content string `json:"content"`
	// Relative path within the workspace files directory
	Path string `json:"path"`
}

type SessionWorkspaceCreateFileResult struct {
}

type SessionWorkspaceListFilesResult struct {
	// Relative file paths in the workspace files directory
	Files []string `json:"files"`
}

type SessionWorkspaceReadFileParams struct {
	// Relative path within the workspace files directory
	Path string `json:"path"`
}

type SessionWorkspaceReadFileResult struct {
	// File content as a UTF-8 string
	Content string `json:"content"`
}

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

type Signal string

type Supports struct {
	// Whether this model supports reasoning effort configuration
	ReasoningEffort *bool `json:"reasoningEffort,omitempty"`
	// Whether this model supports vision/image input
	Vision *bool `json:"vision,omitempty"`
}

type Tool struct {
	// Description of what the tool does
	Description string `json:"description"`
	// Optional instructions for how to use this tool effectively
	Instructions *string `json:"instructions,omitempty"`
	// Tool identifier (e.g., "bash", "grep", "str_replace_editor")
	Name string `json:"name"`
	// Optional namespaced name for declarative filtering (e.g., "playwright/navigate" for MCP
	// tools)
	NamespacedName *string `json:"namespacedName,omitempty"`
	// JSON Schema for the tool's input parameters
	Parameters map[string]interface{} `json:"parameters,omitempty"`
}

type ToolsListParams struct {
	// Optional model ID — when provided, the returned tool list reflects model-specific
	// overrides
	Model *string `json:"model,omitempty"`
}

type ToolsListResult struct {
	// List of available built-in tools with metadata
	Tools []Tool `json:"tools"`
}

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

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