# Shared Types
```python
from openai.types import (
AllModels,
ChatModel,
ComparisonFilter,
CompoundFilter,
CustomToolInputFormat,
DecisionInputJSON,
DecisionQuestionInputImage,
DecisionQuestionInputPart,
DecisionQuestionInputText,
ErrorObject,
FunctionDefinition,
FunctionParameters,
Metadata,
OAuthErrorCode,
Reasoning,
ReasoningEffort,
ResponseFormatJSONObject,
ResponseFormatJSONSchema,
ResponseFormatText,
ResponseFormatTextGrammar,
ResponseFormatTextPython,
ResponsesModel,
)
```
# Decisions
Types:
```python
from openai.types import (
Decision,
DecisionInputImageParam,
DecisionInputMessageParam,
DecisionInputPartUnionParam,
DecisionInputTextParam,
DecisionPromptCacheBreakpointParam,
)
```
Methods:
- client.decisions.create(\*\*params) -> Decision
# Completions
Types:
```python
from openai.types import Completion, CompletionChoice, CompletionUsage
```
Methods:
- client.completions.create(\*\*params) -> Completion
# Chat
Types:
```python
from openai.types import ChatModel
```
## Completions
Types:
```python
from openai.types.chat import (
ChatCompletionAllowedToolsParam,
ChatCompletion,
ChatCompletionAllowedToolChoiceParam,
ChatCompletionAssistantMessageParam,
ChatCompletionAudio,
ChatCompletionAudioParam,
ChatCompletionChunk,
ChatCompletionContentPartParam,
ChatCompletionContentPartImage,
ChatCompletionContentPartInputAudioParam,
ChatCompletionContentPartRefusalParam,
ChatCompletionContentPartText,
ChatCompletionCustomToolParam,
ChatCompletionDeleted,
ChatCompletionDeveloperMessageParam,
ChatCompletionFunctionCallOptionParam,
ChatCompletionFunctionMessageParam,
ChatCompletionFunctionTool,
ChatCompletionMessage,
ChatCompletionMessageCustomToolCall,
ChatCompletionMessageFunctionToolCall,
ChatCompletionMessageParam,
ChatCompletionMessageToolCallUnion,
ChatCompletionModality,
ChatCompletionNamedToolChoiceParam,
ChatCompletionNamedToolChoiceCustomParam,
ChatCompletionPredictionContentParam,
ChatCompletionRole,
ChatCompletionStoreMessage,
ChatCompletionStreamOptionsParam,
ChatCompletionSystemMessageParam,
ChatCompletionTokenLogprob,
ChatCompletionToolUnionParam,
ChatCompletionToolChoiceOptionParam,
ChatCompletionToolMessageParam,
ChatCompletionUserMessageParam,
ChatCompletionReasoningEffort,
)
```
Methods:
- client.chat.completions.create(\*\*params) -> ChatCompletion
- client.chat.completions.retrieve(completion_id) -> ChatCompletion
- client.chat.completions.update(completion_id, \*\*params) -> ChatCompletion
- client.chat.completions.list(\*\*params) -> SyncCursorPage[ChatCompletion]
- client.chat.completions.delete(completion_id) -> ChatCompletionDeleted
- client.chat.completions.parse(\*, messages, model, audio=..., response_format=..., frequency_penalty=..., function_call=..., functions=..., logit_bias=..., logprobs=..., max_completion_tokens=..., max_tokens=..., metadata=..., modalities=..., moderation=..., n=..., parallel_tool_calls=..., prediction=..., presence_penalty=..., prompt_cache_key=..., prompt_cache_options=..., prompt_cache_retention=..., reasoning_effort=..., safety_identifier=..., seed=..., service_tier=..., stop=..., store=..., stream_options=..., temperature=..., tool_choice=..., tools=..., top_logprobs=..., top_p=..., user=..., verbosity=..., web_search_options=..., extra_headers=..., extra_query=..., extra_body=..., timeout=...) -> ParsedChatCompletion[ResponseFormatT]
- client.chat.completions.stream(\*, messages, model, audio=..., response_format=..., frequency_penalty=..., function_call=..., functions=..., logit_bias=..., logprobs=..., max_completion_tokens=..., max_tokens=..., metadata=..., modalities=..., moderation=..., n=..., parallel_tool_calls=..., prediction=..., presence_penalty=..., prompt_cache_key=..., prompt_cache_options=..., prompt_cache_retention=..., reasoning_effort=..., safety_identifier=..., seed=..., service_tier=..., stop=..., store=..., stream_options=..., temperature=..., tool_choice=..., tools=..., top_logprobs=..., top_p=..., user=..., verbosity=..., web_search_options=..., extra_headers=..., extra_query=..., extra_body=..., timeout=...) -> ChatCompletionStreamManager[ResponseFormatT]
### Messages
Methods:
- client.chat.completions.messages.list(completion_id, \*\*params) -> SyncCursorPage[ChatCompletionStoreMessage]
# Embeddings
Types:
```python
from openai.types import CreateEmbeddingResponse, Embedding, EmbeddingModel
```
Methods:
- client.embeddings.create(\*\*params) -> CreateEmbeddingResponse
# Files
Types:
```python
from openai.types import FileContent, FileDeleted, FileObject, FilePurpose
```
Methods:
- client.files.create(\*\*params) -> FileObject
- client.files.retrieve(file_id) -> FileObject
- client.files.list(\*\*params) -> SyncCursorPage[FileObject]
- client.files.delete(file_id) -> FileDeleted
- client.files.content(file_id) -> HttpxBinaryResponseContent
- client.files.retrieve_content(file_id) -> str
- client.files.wait_for_processing(id, poll_interval=..., max_wait_seconds=...) -> FileObject
# Images
Types:
```python
from openai.types import (
Image,
ImageEditCompletedEvent,
ImageEditPartialImageEvent,
ImageEditStreamEvent,
ImageGenCompletedEvent,
ImageGenPartialImageEvent,
ImageGenStreamEvent,
ImageModel,
ImagesResponse,
)
```
Methods:
- client.images.create_variation(\*\*params) -> ImagesResponse
- client.images.edit(\*\*params) -> ImagesResponse
- client.images.generate(\*\*params) -> ImagesResponse
# ContentProvenanceChecks
Types:
```python
from openai.types import ContentProvenanceCheck
```
Methods:
- client.content_provenance_checks.create(\*\*params) -> ContentProvenanceCheck
# Audio
Types:
```python
from openai.types import AudioModel, AudioResponseFormat
```
## Transcriptions
Types:
```python
from openai.types.audio import (
Transcription,
TranscriptionDiarized,
TranscriptionDiarizedSegment,
TranscriptionInclude,
TranscriptionLanguage,
TranscriptionSegment,
TranscriptionStreamEvent,
TranscriptionTextDeltaEvent,
TranscriptionTextDoneEvent,
TranscriptionTextSegmentEvent,
TranscriptionVerbose,
TranscriptionWord,
TranscriptionCreateResponse,
)
```
Methods:
- client.audio.transcriptions.create(\*\*params) -> TranscriptionCreateResponse
## Translations
Types:
```python
from openai.types.audio import Translation, TranslationVerbose, TranslationCreateResponse
```
Methods:
- client.audio.translations.create(\*\*params) -> TranslationCreateResponse
## Speech
Types:
```python
from openai.types.audio import SpeechModel
```
Methods:
- client.audio.speech.create(\*\*params) -> HttpxBinaryResponseContent
## Voices
Types:
```python
from openai.types.audio import Voice
```
Methods:
- client.audio.voices.create(\*\*params) -> Voice
## VoiceConsents
Types:
```python
from openai.types.audio import VoiceConsent, VoiceConsentDeleted
```
Methods:
- client.audio.voice_consents.create(\*\*params) -> VoiceConsent
- client.audio.voice_consents.retrieve(consent_id) -> VoiceConsent
- client.audio.voice_consents.update(consent_id, \*\*params) -> VoiceConsent
- client.audio.voice_consents.list(\*\*params) -> SyncCursorPage[VoiceConsent]
- client.audio.voice_consents.delete(consent_id) -> VoiceConsentDeleted
# Moderations
Types:
```python
from openai.types import (
Moderation,
ModerationImageURLInputParam,
ModerationModel,
ModerationMultiModalInputParam,
ModerationTextInputParam,
ModerationCreateResponse,
)
```
Methods:
- client.moderations.create(\*\*params) -> ModerationCreateResponse
# Models
Types:
```python
from openai.types import Model, ModelDeleted
```
Methods:
- client.models.retrieve(model) -> Model
- client.models.list() -> SyncPage[Model]
- client.models.delete(model) -> ModelDeleted
# FineTuning
## Methods
Types:
```python
from openai.types.fine_tuning import (
DpoHyperparameters,
DpoMethod,
ReinforcementHyperparameters,
ReinforcementMethod,
SupervisedHyperparameters,
SupervisedMethod,
)
```
## Jobs
Types:
```python
from openai.types.fine_tuning import (
FineTuningJob,
FineTuningJobEvent,
FineTuningJobWandbIntegration,
FineTuningJobWandbIntegrationObject,
FineTuningJobIntegration,
)
```
Methods:
- client.fine_tuning.jobs.create(\*\*params) -> FineTuningJob
- client.fine_tuning.jobs.retrieve(fine_tuning_job_id) -> FineTuningJob
- client.fine_tuning.jobs.list(\*\*params) -> SyncCursorPage[FineTuningJob]
- client.fine_tuning.jobs.cancel(fine_tuning_job_id) -> FineTuningJob
- client.fine_tuning.jobs.list_events(fine_tuning_job_id, \*\*params) -> SyncCursorPage[FineTuningJobEvent]
- client.fine_tuning.jobs.pause(fine_tuning_job_id) -> FineTuningJob
- client.fine_tuning.jobs.resume(fine_tuning_job_id) -> FineTuningJob
### Checkpoints
Types:
```python
from openai.types.fine_tuning.jobs import FineTuningJobCheckpoint
```
Methods:
- client.fine_tuning.jobs.checkpoints.list(fine_tuning_job_id, \*\*params) -> SyncCursorPage[FineTuningJobCheckpoint]
## Checkpoints
### Permissions
Types:
```python
from openai.types.fine_tuning.checkpoints import (
PermissionCreateResponse,
PermissionRetrieveResponse,
PermissionListResponse,
PermissionDeleteResponse,
)
```
Methods:
- client.fine_tuning.checkpoints.permissions.create(fine_tuned_model_checkpoint, \*\*params) -> SyncPage[PermissionCreateResponse]
- client.fine_tuning.checkpoints.permissions.retrieve(fine_tuned_model_checkpoint, \*\*params) -> PermissionRetrieveResponse
- client.fine_tuning.checkpoints.permissions.list(fine_tuned_model_checkpoint, \*\*params) -> SyncConversationCursorPage[PermissionListResponse]
- client.fine_tuning.checkpoints.permissions.delete(permission_id, \*, fine_tuned_model_checkpoint) -> PermissionDeleteResponse
## Alpha
### Graders
Types:
```python
from openai.types.fine_tuning.alpha import GraderRunResponse, GraderValidateResponse
```
Methods:
- client.fine_tuning.alpha.graders.run(\*\*params) -> GraderRunResponse
- client.fine_tuning.alpha.graders.validate(\*\*params) -> GraderValidateResponse
# Graders
## GraderModels
Types:
```python
from openai.types.graders import (
GraderInputs,
LabelModelGrader,
MultiGrader,
PythonGrader,
ScoreModelGrader,
StringCheckGrader,
TextSimilarityGrader,
)
```
# VectorStores
Types:
```python
from openai.types import (
AutoFileChunkingStrategyParam,
FileChunkingStrategy,
FileChunkingStrategyParam,
OtherFileChunkingStrategyObject,
StaticFileChunkingStrategy,
StaticFileChunkingStrategyObject,
StaticFileChunkingStrategyObjectParam,
VectorStore,
VectorStoreDeleted,
VectorStoreSearchResponse,
)
```
Methods:
- client.vector_stores.create(\*\*params) -> VectorStore
- client.vector_stores.retrieve(vector_store_id) -> VectorStore
- client.vector_stores.update(vector_store_id, \*\*params) -> VectorStore
- client.vector_stores.list(\*\*params) -> SyncCursorPage[VectorStore]
- client.vector_stores.delete(vector_store_id) -> VectorStoreDeleted
- client.vector_stores.search(vector_store_id, \*\*params) -> SyncPage[VectorStoreSearchResponse]
## Files
Types:
```python
from openai.types.vector_stores import VectorStoreFile, VectorStoreFileDeleted, FileContentResponse
```
Methods:
- client.vector_stores.files.create(vector_store_id, \*\*params) -> VectorStoreFile
- client.vector_stores.files.retrieve(file_id, \*, vector_store_id) -> VectorStoreFile
- client.vector_stores.files.update(file_id, \*, vector_store_id, \*\*params) -> VectorStoreFile
- client.vector_stores.files.list(vector_store_id, \*\*params) -> SyncCursorPage[VectorStoreFile]
- client.vector_stores.files.delete(file_id, \*, vector_store_id) -> VectorStoreFileDeleted
- client.vector_stores.files.content(file_id, \*, vector_store_id) -> SyncPage[FileContentResponse]
- client.vector_stores.files.create_and_poll(file_id, vector_store_id=..., attributes=..., poll_interval_ms=..., max_wait_seconds=..., chunking_strategy=..., extra_headers=..., extra_query=..., extra_body=..., timeout=...) -> VectorStoreFile
- client.vector_stores.files.poll(file_id, vector_store_id=..., poll_interval_ms=..., max_wait_seconds=...) -> VectorStoreFile
- client.vector_stores.files.upload(vector_store_id=..., file=..., chunking_strategy=...) -> VectorStoreFile
- client.vector_stores.files.upload_and_poll(vector_store_id=..., file=..., attributes=..., poll_interval_ms=..., max_wait_seconds=..., chunking_strategy=...) -> VectorStoreFile
## FileBatches
Types:
```python
from openai.types.vector_stores import VectorStoreFileBatch
```
Methods:
- client.vector_stores.file_batches.create(vector_store_id, \*\*params) -> VectorStoreFileBatch
- client.vector_stores.file_batches.retrieve(batch_id, \*, vector_store_id) -> VectorStoreFileBatch
- client.vector_stores.file_batches.cancel(batch_id, \*, vector_store_id) -> VectorStoreFileBatch
- client.vector_stores.file_batches.list_files(batch_id, \*, vector_store_id, \*\*params) -> SyncCursorPage[VectorStoreFile]
- client.vector_stores.file_batches.create_and_poll(vector_store_id, attributes=..., chunking_strategy=..., file_ids=..., files=..., poll_interval_ms=..., extra_headers=..., extra_query=..., extra_body=..., timeout=...) -> VectorStoreFileBatch
- client.vector_stores.file_batches.poll(batch_id, vector_store_id=..., poll_interval_ms=...) -> VectorStoreFileBatch
- client.vector_stores.file_batches.upload_and_poll(vector_store_id, files=..., max_concurrency=..., file_ids=..., poll_interval_ms=..., chunking_strategy=...) -> VectorStoreFileBatch
# Safety
## Cases
Types:
```python
from openai.types.safety import SafetyCase
```
Methods:
- client.safety.cases.retrieve(id) -> SafetyCase
## Alerts
Types:
```python
from openai.types.safety import SafetyAlert
```
Methods:
- client.safety.alerts.retrieve(id) -> SafetyAlert
# [Webhooks](src/openai/resources/webhooks/api.md)
# Beta
## Agents
Types:
```python
from openai.types.beta import (
Agent,
AgentBrowserAuthenticationCancelParam,
AgentBrowserAuthenticationSubmitParam,
AgentBrowserOriginAccessParam,
AgentCloseSubagentCallItem,
AgentCommandExecutionItem,
AgentContent,
AgentCreateSubagentCallItem,
AgentDeleted,
AgentFunctionCallItem,
AgentFunctionCallOutput,
AgentFunctionCallOutputParam,
AgentFunctionCallStatus,
AgentInterruptSubagentCallItem,
AgentMcpCallItem,
AgentOutputCommandExecutionOutputDeltaEvent,
AgentOutputItem,
AgentOutputItemStatus,
AgentReasoning,
AgentReasoningItem,
AgentReasoningParam,
AgentResumeSubagentCallItem,
AgentSendSubagentInputCallItem,
AgentSession,
AgentSessionAssistantMessage,
AgentSessionCreatedEvent,
AgentSessionDeleted,
AgentSessionEnvironmentConnectedEvent,
AgentSessionEnvironmentDisconnectedEvent,
AgentSessionEnvironmentExpiredEvent,
AgentSessionEnvironmentFailedEvent,
AgentSessionEnvironmentPendingEvent,
AgentSessionEnvironmentReadyEvent,
AgentSessionEnvironmentResetEvent,
AgentSessionEnvironmentState,
AgentSessionEnvironmentSuspendedEvent,
AgentSessionErrorEvent,
AgentSessionEvent,
AgentSessionFailedEvent,
AgentSessionIdleEvent,
AgentSessionInProgressEvent,
AgentSessionInputMessageParam,
AgentSessionInputParam,
AgentSessionItem,
AgentSessionMessage,
AgentSessionMessageContent,
AgentSessionRequiresActionEvent,
AgentSessionSubagentActiveEvent,
AgentSessionSubagentClosedEvent,
AgentSessionSubagentCreatedEvent,
AgentSessionTurnCancelledEvent,
AgentSessionTurnCompletedEvent,
AgentSessionTurnContentPartAddedEvent,
AgentSessionTurnContentPartDoneEvent,
AgentSessionTurnCreatedEvent,
AgentSessionTurnFailedEvent,
AgentSessionTurnInProgressEvent,
AgentSessionTurnItemAddedEvent,
AgentSessionTurnItemDoneEvent,
AgentSessionTurnOutputTextDeltaEvent,
AgentSessionTurnOutputTextDoneEvent,
AgentSessionTurnReasoningSummaryPartAddedEvent,
AgentSessionTurnReasoningSummaryPartDoneEvent,
AgentSessionTurnReasoningSummaryTextDeltaEvent,
AgentSessionTurnReasoningSummaryTextDoneEvent,
AgentText,
AgentTextParam,
AgentTool,
AgentToolParam,
AgentWaitForSubagentsCallItem,
AgentWebSearchCallItem,
Environment,
EnvironmentParam,
HostedEnvironmentFile,
HostedEnvironmentFileID,
HostedEnvironmentFileParam,
HostedPlugin,
HostedPluginParam,
HostedSkill,
HostedSkillParam,
HostedSkillReference,
InlineCapabilitySourceParam,
InputContent,
InputContentParam,
McpTransport,
McpTransportParam,
MultiAgentConfig,
MultiAgentConfigParam,
OutputText,
PersistedAgentTool,
PersistedAgentToolParam,
PersistedMcpTransport,
PersistedMcpTransportParam,
SessionError,
SessionTurnError,
SetupCommandParam,
Subagent,
SummaryText,
TextFormat,
TextFormatParam,
TokenUsage,
WebSearchAction,
)
```
Methods:
- client.beta.agents.create(\*\*params) -> Agent
- client.beta.agents.retrieve(agent_id) -> Agent
- client.beta.agents.update(agent_id, \*\*params) -> Agent
- client.beta.agents.list(\*\*params) -> SyncCursorPage[Agent]
- client.beta.agents.delete(agent_id) -> AgentDeleted
### Environments
Types:
```python
from openai.types.beta.agents import EnvironmentInfo
```
Methods:
- client.beta.agents.environments.create(\*\*params) -> EnvironmentInfo
- client.beta.agents.environments.retrieve(environment_id) -> EnvironmentInfo
- client.beta.agents.environments.list(\*\*params) -> SyncCursorPage[EnvironmentInfo]
#### Files
Types:
```python
from openai.types.beta.agents.environments import EnvironmentFile
```
Methods:
- client.beta.agents.environments.files.create(environment_id, \*\*params) -> EnvironmentFile
- client.beta.agents.environments.files.list(environment_id, \*\*params) -> SyncTokenPage[EnvironmentFile]
- client.beta.agents.environments.files.prepare(files, \*, extra_headers=..., extra_query=..., extra_body=..., timeout=...) -> PreparedAgentFiles
- client.beta.agents.environments.files.prepare_directory(root, \*, destination, include, extra_headers=..., extra_query=..., extra_body=..., timeout=...) -> PreparedAgentFiles
- client.beta.agents.environments.files.upload(environment_id, \*, file, path, extra_headers=..., extra_query=..., extra_body=..., timeout=...) -> StagedAgentFile
#### Templates
Types:
```python
from openai.types.beta.agents.environments import EnvironmentTemplate, EnvironmentTemplateDeleted
```
Methods:
- client.beta.agents.environments.templates.create(\*\*params) -> EnvironmentTemplate
- client.beta.agents.environments.templates.retrieve(environment_template_id) -> EnvironmentTemplate
- client.beta.agents.environments.templates.update(environment_template_id, \*\*params) -> EnvironmentTemplate
- client.beta.agents.environments.templates.list(\*\*params) -> SyncCursorPage[EnvironmentTemplate]
- client.beta.agents.environments.templates.delete(environment_template_id) -> EnvironmentTemplateDeleted
### Vaults
Types:
```python
from openai.types.beta.agents import Vault, VaultDeleted, VaultStatus, VaultStatusFilterParam
```
Methods:
- client.beta.agents.vaults.create(\*\*params) -> Vault
- client.beta.agents.vaults.retrieve(vault_id) -> Vault
- client.beta.agents.vaults.update(vault_id, \*\*params) -> Vault
- client.beta.agents.vaults.list(\*\*params) -> SyncCursorPage[Vault]
- client.beta.agents.vaults.delete(vault_id) -> VaultDeleted
#### Credentials
Types:
```python
from openai.types.beta.agents.vaults import (
Credential,
CredentialAuth,
CredentialAuthCreateParam,
CredentialAuthRotateParam,
CredentialDeleted,
CredentialNetworking,
CredentialNetworkingParam,
McpOauthTokenEndpointAuth,
McpOauthTokenEndpointAuthCreateParam,
McpOauthTokenEndpointAuthRotateParam,
)
```
Methods:
- client.beta.agents.vaults.credentials.create(vault_id, \*\*params) -> Credential
- client.beta.agents.vaults.credentials.retrieve(credential_id, \*, vault_id) -> Credential
- client.beta.agents.vaults.credentials.update(credential_id, \*, vault_id, \*\*params) -> Credential
- client.beta.agents.vaults.credentials.list(vault_id, \*\*params) -> SyncCursorPage[Credential]
- client.beta.agents.vaults.credentials.delete(credential_id, \*, vault_id) -> CredentialDeleted
### Sessions
Methods:
- client.beta.agents.sessions.create(\*\*params) -> AgentSession
- client.beta.agents.sessions.retrieve(session_id) -> AgentSession
- client.beta.agents.sessions.update(session_id, \*\*params) -> AgentSession
- client.beta.agents.sessions.list(\*\*params) -> SyncCursorPage[AgentSession]
- client.beta.agents.sessions.delete(session_id) -> AgentSessionDeleted
- client.beta.agents.sessions.stream(session_id, \*, input, output_type=..., tool_handlers=..., on_tool_error=..., idempotency_key=..., extra_headers=..., timeout=...) -> AgentSessionStream[OutputT]
#### Subagents
Methods:
- client.beta.agents.sessions.subagents.retrieve(subagent_id, \*, session_id) -> Subagent
- client.beta.agents.sessions.subagents.list(session_id, \*\*params) -> SyncCursorPage[Subagent]
##### Items
Methods:
- client.beta.agents.sessions.subagents.items.list(subagent_id, \*, session_id, \*\*params) -> SyncCursorPage[AgentSessionItem]
##### Turns
Methods:
- client.beta.agents.sessions.subagents.turns.retrieve(turn_id, \*, session_id, subagent_id) -> Turn
- client.beta.agents.sessions.subagents.turns.list(subagent_id, \*, session_id, \*\*params) -> SyncCursorPage[Turn]
###### Items
Methods:
- client.beta.agents.sessions.subagents.turns.items.list(turn_id, \*, session_id, subagent_id, \*\*params) -> SyncCursorPage[AgentSessionItem]
#### Artifacts
Types:
```python
from openai.types.beta.agents.sessions import SessionArtifact, SessionArtifactDeleted
```
Methods:
- client.beta.agents.sessions.artifacts.retrieve(artifact_id, \*, session_id) -> SessionArtifact
- client.beta.agents.sessions.artifacts.list(session_id, \*\*params) -> SyncCursorPage[SessionArtifact]
- client.beta.agents.sessions.artifacts.delete(artifact_id, \*, session_id) -> SessionArtifactDeleted
- client.beta.agents.sessions.artifacts.content(artifact_id, \*, session_id) -> HttpxBinaryResponseContent
- client.beta.agents.sessions.artifacts.for_result(result) -> AgentResultArtifacts
#### Items
Methods:
- client.beta.agents.sessions.items.list(session_id, \*\*params) -> SyncCursorPage[AgentSessionItem]
#### Events
Methods:
- client.beta.agents.sessions.events.create(session_id, \*\*params) -> None
- client.beta.agents.sessions.events.stream(session_id) -> AgentSessionEvent
#### Traces
Types:
```python
from openai.types.beta.agents.sessions import SessionTrace
```
Methods:
- client.beta.agents.sessions.traces.list(session_id, \*\*params) -> SyncCursorPage[SessionTrace]
#### Turns
Types:
```python
from openai.types.beta.agents.sessions import Turn
```
Methods:
- client.beta.agents.sessions.turns.retrieve(turn_id, \*, session_id) -> Turn
- client.beta.agents.sessions.turns.list(session_id, \*\*params) -> SyncCursorPage[Turn]
##### Items
Methods:
- client.beta.agents.sessions.turns.items.list(turn_id, \*, session_id, \*\*params) -> SyncConversationCursorPage[AgentSessionItem]
## Responses
Types:
```python
from openai.types.beta import (
BetaApplyPatchTool,
BetaCompactedResponse,
BetaComputerAction,
BetaComputerActionList,
BetaComputerTool,
BetaComputerUsePreviewTool,
BetaContainerAuto,
BetaContainerNetworkPolicyAllowlist,
BetaContainerNetworkPolicyDisabled,
BetaContainerNetworkPolicyDomainSecret,
BetaContainerReference,
BetaCustomTool,
BetaEasyInputMessage,
BetaFileSearchTool,
BetaFunctionShellTool,
BetaFunctionTool,
BetaImageDetail,
BetaInlineSkill,
BetaInlineSkillSource,
BetaLocalEnvironment,
BetaLocalSkill,
BetaMcpToolCallError,
BetaNamespaceTool,
BetaResponse,
BetaResponseApplyPatchToolCall,
BetaResponseApplyPatchToolCallOutput,
BetaResponseAudioDeltaEvent,
BetaResponseAudioDoneEvent,
BetaResponseAudioTranscriptDeltaEvent,
BetaResponseAudioTranscriptDoneEvent,
BetaResponseCodeInterpreterCallCodeDeltaEvent,
BetaResponseCodeInterpreterCallCodeDoneEvent,
BetaResponseCodeInterpreterCallCompletedEvent,
BetaResponseCodeInterpreterCallInProgressEvent,
BetaResponseCodeInterpreterCallInterpretingEvent,
BetaResponseCodeInterpreterToolCall,
BetaResponseCompactionCompactingEvent,
BetaResponseCompactionItem,
BetaResponseCompactionItemParam,
BetaResponseCompletedEvent,
BetaResponseComputerToolCall,
BetaResponseComputerToolCallOutputItem,
BetaResponseComputerToolCallOutputScreenshot,
BetaResponseConfigurationUpdateItem,
BetaResponseConfigurationUpdateItemParam,
BetaResponseContainerReference,
BetaResponseContentPartAddedEvent,
BetaResponseContentPartDoneEvent,
BetaResponseConversationParam,
BetaResponseCreatedEvent,
BetaResponseCustomToolCall,
BetaResponseCustomToolCallInputDeltaEvent,
BetaResponseCustomToolCallInputDoneEvent,
BetaResponseCustomToolCallItem,
BetaResponseCustomToolCallOutput,
BetaResponseCustomToolCallOutputItem,
BetaResponseError,
BetaResponseErrorEvent,
BetaResponseFailedEvent,
BetaResponseFileSearchCallCompletedEvent,
BetaResponseFileSearchCallInProgressEvent,
BetaResponseFileSearchCallSearchingEvent,
BetaResponseFileSearchToolCall,
BetaResponseFormatTextConfig,
BetaResponseFormatTextJSONSchemaConfig,
BetaResponseFunctionCallArgumentsDeltaEvent,
BetaResponseFunctionCallArgumentsDoneEvent,
BetaResponseFunctionCallOutputItem,
BetaResponseFunctionCallOutputItemList,
BetaResponseFunctionShellCallOutputContent,
BetaResponseFunctionShellToolCall,
BetaResponseFunctionShellToolCallOutput,
BetaResponseFunctionToolCall,
BetaResponseFunctionToolCallItem,
BetaResponseFunctionToolCallOutputItem,
BetaResponseFunctionWebSearch,
BetaResponseImageGenCallCompletedEvent,
BetaResponseImageGenCallGeneratingEvent,
BetaResponseImageGenCallInProgressEvent,
BetaResponseImageGenCallPartialImageEvent,
BetaResponseInProgressEvent,
BetaResponseIncludable,
BetaResponseIncompleteEvent,
BetaResponseInjectCreatedEvent,
BetaResponseInjectEvent,
BetaResponseInjectFailedEvent,
BetaResponseInput,
BetaResponseInputContent,
BetaResponseInputFile,
BetaResponseInputFileContent,
BetaResponseInputImage,
BetaResponseInputImageContent,
BetaResponseInputItem,
BetaResponseInputMessageContentList,
BetaResponseInputMessageItem,
BetaResponseInputText,
BetaResponseInputTextContent,
BetaResponseItem,
BetaResponseLocalEnvironment,
BetaResponseMcpCallArgumentsDeltaEvent,
BetaResponseMcpCallArgumentsDoneEvent,
BetaResponseMcpCallCompletedEvent,
BetaResponseMcpCallFailedEvent,
BetaResponseMcpCallInProgressEvent,
BetaResponseMcpListToolsCompletedEvent,
BetaResponseMcpListToolsFailedEvent,
BetaResponseMcpListToolsInProgressEvent,
BetaResponseOutputItem,
BetaResponseOutputItemAddedEvent,
BetaResponseOutputItemDoneEvent,
BetaResponseOutputMessage,
BetaResponseOutputRefusal,
BetaResponseOutputText,
BetaResponseOutputTextAnnotationAddedEvent,
BetaResponsePrompt,
BetaResponseQueuedEvent,
BetaResponseReasoningItem,
BetaResponseReasoningSummaryPartAddedEvent,
BetaResponseReasoningSummaryPartDoneEvent,
BetaResponseReasoningSummaryTextDeltaEvent,
BetaResponseReasoningSummaryTextDoneEvent,
BetaResponseReasoningTextDeltaEvent,
BetaResponseReasoningTextDoneEvent,
BetaResponseRefusalDeltaEvent,
BetaResponseRefusalDoneEvent,
BetaResponseShellCallCommandAddedEvent,
BetaResponseShellCallCommandDeltaEvent,
BetaResponseShellCallCommandDoneEvent,
BetaResponseShellCallOutputContentDeltaEvent,
BetaResponseShellCallOutputContentDoneEvent,
BetaResponseStatus,
BetaResponseSteerAcceptedEvent,
BetaResponseSteerErrorCode,
BetaResponseSteerEvent,
BetaResponseSteerFailedEvent,
BetaResponseSteerInput,
BetaResponseSteerInputContent,
BetaResponseSteerPendingEvent,
BetaResponseSteerPendingReason,
BetaResponseSteerRequiredInput,
BetaResponseStreamEvent,
BetaResponseTextConfig,
BetaResponseTextDeltaEvent,
BetaResponseTextDoneEvent,
BetaResponseToolSearchCall,
BetaResponseToolSearchOutputItem,
BetaResponseToolSearchOutputItemParam,
BetaResponseUsage,
BetaResponseWebSearchCallCompletedEvent,
BetaResponseWebSearchCallInProgressEvent,
BetaResponseWebSearchCallSearchingEvent,
BetaResponsesClientEvent,
BetaResponsesServerEvent,
BetaServiceTier,
BetaSkillReference,
BetaTool,
BetaToolChoiceAllowed,
BetaToolChoiceApplyPatch,
BetaToolChoiceCustom,
BetaToolChoiceFunction,
BetaToolChoiceMcp,
BetaToolChoiceOptions,
BetaToolChoiceShell,
BetaToolChoiceTypes,
BetaToolSearchOutputNamespaceTool,
BetaToolSearchTool,
BetaWebSearchPreviewTool,
BetaWebSearchTool,
)
```
Methods:
- client.beta.responses.create(\*\*params) -> BetaResponse
- client.beta.responses.retrieve(response_id, \*\*params) -> BetaResponse
- client.beta.responses.delete(response_id) -> None
- client.beta.responses.cancel(response_id) -> BetaResponse
- client.beta.responses.compact(\*\*params) -> BetaCompactedResponse
### InputItems
Types:
```python
from openai.types.beta.responses import BetaResponseItemList
```
Methods:
- client.beta.responses.input_items.list(response_id, \*\*params) -> SyncCursorPage[BetaResponseItem]
### InputTokens
Types:
```python
from openai.types.beta.responses import InputTokenCountResponse
```
Methods:
- client.beta.responses.input_tokens.count(\*\*params) -> InputTokenCountResponse
## ChatKit
Types:
```python
from openai.types.beta import ChatKitWorkflow
```
### Sessions
Methods:
- client.beta.chatkit.sessions.create(\*\*params) -> ChatSession
- client.beta.chatkit.sessions.cancel(session_id) -> ChatSession
### Threads
Types:
```python
from openai.types.beta.chatkit import (
ChatSession,
ChatSessionAutomaticThreadTitling,
ChatSessionChatKitConfiguration,
ChatSessionChatKitConfigurationParam,
ChatSessionExpiresAfterParam,
ChatSessionFileUpload,
ChatSessionHistory,
ChatSessionRateLimits,
ChatSessionRateLimitsParam,
ChatSessionStatus,
ChatSessionWorkflowParam,
ChatKitAttachment,
ChatKitResponseOutputText,
ChatKitThread,
ChatKitThreadAssistantMessageItem,
ChatKitThreadItemList,
ChatKitThreadUserMessageItem,
ChatKitWidgetItem,
ThreadDeleteResponse,
)
```
Methods:
- client.beta.chatkit.threads.retrieve(thread_id) -> ChatKitThread
- client.beta.chatkit.threads.list(\*\*params) -> SyncConversationCursorPage[ChatKitThread]
- client.beta.chatkit.threads.delete(thread_id) -> ThreadDeleteResponse
- client.beta.chatkit.threads.list_items(thread_id, \*\*params) -> SyncConversationCursorPage[Data]
## [Realtime](docs/beta-realtime-api.md)
## Assistants
Types:
```python
from openai.types.beta import (
Assistant,
AssistantDeleted,
AssistantStreamEvent,
AssistantTool,
CodeInterpreterTool,
FileSearchTool,
FunctionTool,
)
```
Methods:
- client.beta.assistants.create(\*\*params) -> Assistant
- client.beta.assistants.retrieve(assistant_id) -> Assistant
- client.beta.assistants.update(assistant_id, \*\*params) -> Assistant
- client.beta.assistants.list(\*\*params) -> SyncCursorPage[Assistant]
- client.beta.assistants.delete(assistant_id) -> AssistantDeleted
## Threads
Types:
```python
from openai.types.beta import (
AssistantResponseFormatOption,
AssistantToolChoice,
AssistantToolChoiceFunction,
AssistantToolChoiceOption,
Thread,
ThreadDeleted,
)
```
Methods:
- client.beta.threads.create(\*\*params) -> Thread
- client.beta.threads.retrieve(thread_id) -> Thread
- client.beta.threads.update(thread_id, \*\*params) -> Thread
- client.beta.threads.delete(thread_id) -> ThreadDeleted
- client.beta.threads.create_and_run(\*\*params) -> Run
- client.beta.threads.create_and_run_poll(\*, assistant_id, instructions=..., max_completion_tokens=..., max_prompt_tokens=..., metadata=..., model=..., parallel_tool_calls=..., response_format=..., temperature=..., thread=..., tool_choice=..., tool_resources=..., tools=..., top_p=..., truncation_strategy=..., poll_interval_ms=..., extra_headers=..., extra_query=..., extra_body=..., timeout=...) -> Run
- client.beta.threads.create_and_run_stream(\*, assistant_id, instructions=..., max_completion_tokens=..., max_prompt_tokens=..., metadata=..., model=..., parallel_tool_calls=..., response_format=..., temperature=..., thread=..., tool_choice=..., tool_resources=..., tools=..., top_p=..., truncation_strategy=..., event_handler=..., extra_headers=..., extra_query=..., extra_body=..., timeout=...) -> AssistantStreamManager[AssistantEventHandler] | AssistantStreamManager[AssistantEventHandlerT]
### Runs
Types:
```python
from openai.types.beta.threads import RequiredActionFunctionToolCall, Run, RunStatus
```
Methods:
- client.beta.threads.runs.create(thread_id, \*\*params) -> Run
- client.beta.threads.runs.retrieve(run_id, \*, thread_id) -> Run
- client.beta.threads.runs.update(run_id, \*, thread_id, \*\*params) -> Run
- client.beta.threads.runs.list(thread_id, \*\*params) -> SyncCursorPage[Run]
- client.beta.threads.runs.cancel(run_id, \*, thread_id) -> Run
- client.beta.threads.runs.submit_tool_outputs(run_id, \*, thread_id, \*\*params) -> Run
- client.beta.threads.runs.create_and_poll(\*, assistant_id, include=..., additional_instructions=..., additional_messages=..., instructions=..., max_completion_tokens=..., max_prompt_tokens=..., metadata=..., model=..., parallel_tool_calls=..., reasoning_effort=..., response_format=..., temperature=..., tool_choice=..., tools=..., top_p=..., truncation_strategy=..., poll_interval_ms=..., thread_id, extra_headers=..., extra_query=..., extra_body=..., timeout=...) -> Run
- client.beta.threads.runs.create_and_stream(\*, assistant_id, additional_instructions=..., additional_messages=..., instructions=..., max_completion_tokens=..., max_prompt_tokens=..., metadata=..., model=..., parallel_tool_calls=..., reasoning_effort=..., response_format=..., temperature=..., tool_choice=..., tools=..., top_p=..., truncation_strategy=..., thread_id, event_handler=..., extra_headers=..., extra_query=..., extra_body=..., timeout=...) -> AssistantStreamManager[AssistantEventHandler] | AssistantStreamManager[AssistantEventHandlerT]
- client.beta.threads.runs.poll(run_id, thread_id, extra_headers=..., extra_query=..., extra_body=..., timeout=..., poll_interval_ms=...) -> Run
- client.beta.threads.runs.stream(\*, assistant_id, include=..., additional_instructions=..., additional_messages=..., instructions=..., max_completion_tokens=..., max_prompt_tokens=..., metadata=..., model=..., parallel_tool_calls=..., reasoning_effort=..., response_format=..., temperature=..., tool_choice=..., tools=..., top_p=..., truncation_strategy=..., thread_id, event_handler=..., extra_headers=..., extra_query=..., extra_body=..., timeout=...) -> AssistantStreamManager[AssistantEventHandler] | AssistantStreamManager[AssistantEventHandlerT]
- client.beta.threads.runs.submit_tool_outputs_and_poll(\*, tool_outputs, run_id, thread_id, poll_interval_ms=..., extra_headers=..., extra_query=..., extra_body=..., timeout=...) -> Run
- client.beta.threads.runs.submit_tool_outputs_stream(\*, tool_outputs, run_id, thread_id, event_handler=..., extra_headers=..., extra_query=..., extra_body=..., timeout=...) -> AssistantStreamManager[AssistantEventHandler] | AssistantStreamManager[AssistantEventHandlerT]
#### Steps
Types:
```python
from openai.types.beta.threads.runs import (
CodeInterpreterLogs,
CodeInterpreterOutputImage,
CodeInterpreterToolCall,
CodeInterpreterToolCallDelta,
FileSearchToolCall,
FileSearchToolCallDelta,
FunctionToolCall,
FunctionToolCallDelta,
MessageCreationStepDetails,
RunStep,
RunStepDelta,
RunStepDeltaEvent,
RunStepDeltaMessageDelta,
RunStepInclude,
ToolCall,
ToolCallDelta,
ToolCallDeltaObject,
ToolCallsStepDetails,
)
```
Methods:
- client.beta.threads.runs.steps.retrieve(step_id, \*, thread_id, run_id, \*\*params) -> RunStep
- client.beta.threads.runs.steps.list(run_id, \*, thread_id, \*\*params) -> SyncCursorPage[RunStep]
### Messages
Types:
```python
from openai.types.beta.threads import (
Annotation,
AnnotationDelta,
FileCitationAnnotation,
FileCitationDeltaAnnotation,
FilePathAnnotation,
FilePathDeltaAnnotation,
ImageFile,
ImageFileContentBlock,
ImageFileDelta,
ImageFileDeltaBlock,
ImageURL,
ImageURLContentBlock,
ImageURLDelta,
ImageURLDeltaBlock,
Message,
MessageContent,
MessageContentDelta,
MessageContentPartParam,
MessageDeleted,
MessageDelta,
MessageDeltaEvent,
RefusalContentBlock,
RefusalDeltaBlock,
Text,
TextContentBlock,
TextContentBlockParam,
TextDelta,
TextDeltaBlock,
)
```
Methods:
- client.beta.threads.messages.create(thread_id, \*\*params) -> Message
- client.beta.threads.messages.retrieve(message_id, \*, thread_id) -> Message
- client.beta.threads.messages.update(message_id, \*, thread_id, \*\*params) -> Message
- client.beta.threads.messages.list(thread_id, \*\*params) -> SyncCursorPage[Message]
- client.beta.threads.messages.delete(message_id, \*, thread_id) -> MessageDeleted
# Batches
Types:
```python
from openai.types import Batch, BatchError, BatchRequestCounts, BatchUsage
```
Methods:
- client.batches.create(\*\*params) -> Batch
- client.batches.retrieve(batch_id) -> Batch
- client.batches.list(\*\*params) -> SyncCursorPage[Batch]
- client.batches.cancel(batch_id) -> Batch
# Uploads
Types:
```python
from openai.types import Upload
```
Methods:
- client.uploads.create(\*\*params) -> Upload
- client.uploads.cancel(upload_id) -> Upload
- client.uploads.complete(upload_id, \*\*params) -> Upload
- client.uploads.upload_file_chunked(\*, file, mime_type, purpose, filename=..., bytes=..., part_size=..., md5=...) -> Upload
## Parts
Types:
```python
from openai.types.uploads import UploadPart
```
Methods:
- client.uploads.parts.create(upload_id, \*\*params) -> UploadPart
# Admin
## Organization
### AuditLogs
Types:
```python
from openai.types.admin.organization import AuditLogListResponse
```
Methods:
- client.admin.organization.audit_logs.list(\*\*params) -> SyncConversationCursorPage[AuditLogListResponse]
### AdminAPIKeys
Types:
```python
from openai.types.admin.organization import (
AdminAPIKey,
AdminAPIKeyCreateResponse,
AdminAPIKeyDeleteResponse,
)
```
Methods:
- client.admin.organization.admin_api_keys.create(\*\*params) -> AdminAPIKeyCreateResponse
- client.admin.organization.admin_api_keys.retrieve(key_id) -> AdminAPIKey
- client.admin.organization.admin_api_keys.list(\*\*params) -> SyncCursorPage[AdminAPIKey]
- client.admin.organization.admin_api_keys.delete(key_id) -> AdminAPIKeyDeleteResponse
### Usage
Types:
```python
from openai.types.admin.organization import (
CostQuantityUnit,
UsageAudioSpeechesResponse,
UsageAudioTranscriptionsResponse,
UsageCodeInterpreterSessionsResponse,
UsageCompletionsResponse,
UsageCostsResponse,
UsageDecisionsResponse,
UsageEmbeddingsResponse,
UsageFileSearchCallsResponse,
UsageImagesResponse,
UsageModerationsResponse,
UsageVectorStoresResponse,
UsageWebSearchCallsResponse,
)
```
Methods:
- client.admin.organization.usage.audio_speeches(\*\*params) -> UsageAudioSpeechesResponse
- client.admin.organization.usage.audio_transcriptions(\*\*params) -> UsageAudioTranscriptionsResponse
- client.admin.organization.usage.code_interpreter_sessions(\*\*params) -> UsageCodeInterpreterSessionsResponse
- client.admin.organization.usage.completions(\*\*params) -> UsageCompletionsResponse
- client.admin.organization.usage.costs(\*\*params) -> UsageCostsResponse
- client.admin.organization.usage.decisions(\*\*params) -> UsageDecisionsResponse
- client.admin.organization.usage.embeddings(\*\*params) -> UsageEmbeddingsResponse
- client.admin.organization.usage.file_search_calls(\*\*params) -> UsageFileSearchCallsResponse
- client.admin.organization.usage.images(\*\*params) -> UsageImagesResponse
- client.admin.organization.usage.moderations(\*\*params) -> UsageModerationsResponse
- client.admin.organization.usage.vector_stores(\*\*params) -> UsageVectorStoresResponse
- client.admin.organization.usage.web_search_calls(\*\*params) -> UsageWebSearchCallsResponse
### Invites
Types:
```python
from openai.types.admin.organization import Invite, InviteDeleteResponse
```
Methods:
- client.admin.organization.invites.create(\*\*params) -> Invite
- client.admin.organization.invites.retrieve(invite_id) -> Invite
- client.admin.organization.invites.list(\*\*params) -> SyncConversationCursorPage[Invite]
- client.admin.organization.invites.delete(invite_id) -> InviteDeleteResponse
### Users
Types:
```python
from openai.types.admin.organization import OrganizationUser, UserDeleteResponse
```
Methods:
- client.admin.organization.users.retrieve(user_id) -> OrganizationUser
- client.admin.organization.users.update(user_id, \*\*params) -> OrganizationUser
- client.admin.organization.users.list(\*\*params) -> SyncConversationCursorPage[OrganizationUser]
- client.admin.organization.users.delete(user_id) -> UserDeleteResponse
#### Roles
Types:
```python
from openai.types.admin.organization.users import (
RoleCreateResponse,
RoleRetrieveResponse,
RoleListResponse,
RoleDeleteResponse,
)
```
Methods:
- client.admin.organization.users.roles.create(user_id, \*\*params) -> RoleCreateResponse
- client.admin.organization.users.roles.retrieve(role_id, \*, user_id) -> RoleRetrieveResponse
- client.admin.organization.users.roles.list(user_id, \*\*params) -> SyncNextCursorPage[RoleListResponse]
- client.admin.organization.users.roles.delete(role_id, \*, user_id) -> RoleDeleteResponse
### Groups
Types:
```python
from openai.types.admin.organization import Group, GroupUpdateResponse, GroupDeleteResponse
```
Methods:
- client.admin.organization.groups.create(\*\*params) -> Group
- client.admin.organization.groups.retrieve(group_id) -> Group
- client.admin.organization.groups.update(group_id, \*\*params) -> GroupUpdateResponse
- client.admin.organization.groups.list(\*\*params) -> SyncNextCursorPage[Group]
- client.admin.organization.groups.delete(group_id) -> GroupDeleteResponse
#### Users
Types:
```python
from openai.types.admin.organization.groups import (
OrganizationGroupUser,
UserCreateResponse,
UserRetrieveResponse,
UserDeleteResponse,
)
```
Methods:
- client.admin.organization.groups.users.create(group_id, \*\*params) -> UserCreateResponse
- client.admin.organization.groups.users.retrieve(user_id, \*, group_id) -> UserRetrieveResponse
- client.admin.organization.groups.users.list(group_id, \*\*params) -> SyncNextCursorPage[OrganizationGroupUser]
- client.admin.organization.groups.users.delete(user_id, \*, group_id) -> UserDeleteResponse
#### Roles
Types:
```python
from openai.types.admin.organization.groups import (
RoleCreateResponse,
RoleRetrieveResponse,
RoleListResponse,
RoleDeleteResponse,
)
```
Methods:
- client.admin.organization.groups.roles.create(group_id, \*\*params) -> RoleCreateResponse
- client.admin.organization.groups.roles.retrieve(role_id, \*, group_id) -> RoleRetrieveResponse
- client.admin.organization.groups.roles.list(group_id, \*\*params) -> SyncNextCursorPage[RoleListResponse]
- client.admin.organization.groups.roles.delete(role_id, \*, group_id) -> RoleDeleteResponse
### Roles
Types:
```python
from openai.types.admin.organization import Role, RoleDeleteResponse
```
Methods:
- client.admin.organization.roles.create(\*\*params) -> Role
- client.admin.organization.roles.retrieve(role_id) -> Role
- client.admin.organization.roles.update(role_id, \*\*params) -> Role
- client.admin.organization.roles.list(\*\*params) -> SyncNextCursorPage[Role]
- client.admin.organization.roles.delete(role_id) -> RoleDeleteResponse
### DataRetention
Types:
```python
from openai.types.admin.organization import OrganizationDataRetention
```
Methods:
- client.admin.organization.data_retention.retrieve() -> OrganizationDataRetention
- client.admin.organization.data_retention.update(\*\*params) -> OrganizationDataRetention
### ExternalStorage
Types:
```python
from openai.types.admin.organization import (
AwsExternalStorageProvider,
AzureExternalStorageProvider,
ExternalStorageConfiguration,
ExternalStorageDeleted,
GcpExternalStorageProvider,
OciExternalStorageProvider,
)
```
Methods:
- client.admin.organization.external_storage.create(\*\*params) -> ExternalStorageConfiguration
- client.admin.organization.external_storage.retrieve(external_storage_id) -> ExternalStorageConfiguration
- client.admin.organization.external_storage.list(\*\*params) -> SyncCursorPage[ExternalStorageConfiguration]
- client.admin.organization.external_storage.delete(external_storage_id) -> ExternalStorageDeleted
- client.admin.organization.external_storage.validate(external_storage_id) -> ExternalStorageConfiguration
### SpendLimit
Types:
```python
from openai.types.admin.organization import OrganizationSpendLimit, OrganizationSpendLimitDeleted
```
Methods:
- client.admin.organization.spend_limit.retrieve() -> OrganizationSpendLimit
- client.admin.organization.spend_limit.update(\*\*params) -> OrganizationSpendLimit
- client.admin.organization.spend_limit.delete() -> OrganizationSpendLimitDeleted
### SpendAlerts
Types:
```python
from openai.types.admin.organization import OrganizationSpendAlert, OrganizationSpendAlertDeleted
```
Methods:
- client.admin.organization.spend_alerts.create(\*\*params) -> OrganizationSpendAlert
- client.admin.organization.spend_alerts.retrieve(alert_id) -> OrganizationSpendAlert
- client.admin.organization.spend_alerts.update(alert_id, \*\*params) -> OrganizationSpendAlert
- client.admin.organization.spend_alerts.list(\*\*params) -> SyncConversationCursorPage[OrganizationSpendAlert]
- client.admin.organization.spend_alerts.delete(alert_id) -> OrganizationSpendAlertDeleted
### Certificates
Types:
```python
from openai.types.admin.organization import (
Certificate,
CertificateListResponse,
CertificateDeleteResponse,
CertificateActivateResponse,
CertificateDeactivateResponse,
)
```
Methods:
- client.admin.organization.certificates.create(\*\*params) -> Certificate
- client.admin.organization.certificates.retrieve(certificate_id, \*\*params) -> Certificate
- client.admin.organization.certificates.update(certificate_id, \*\*params) -> Certificate
- client.admin.organization.certificates.list(\*\*params) -> SyncConversationCursorPage[CertificateListResponse]
- client.admin.organization.certificates.delete(certificate_id) -> CertificateDeleteResponse
- client.admin.organization.certificates.activate(\*\*params) -> SyncPage[CertificateActivateResponse]
- client.admin.organization.certificates.deactivate(\*\*params) -> SyncPage[CertificateDeactivateResponse]
### Projects
Types:
```python
from openai.types.admin.organization import Project, ProjectResidency
```
Methods:
- client.admin.organization.projects.create(\*\*params) -> Project
- client.admin.organization.projects.retrieve(project_id) -> Project
- client.admin.organization.projects.update(project_id, \*\*params) -> Project
- client.admin.organization.projects.list(\*\*params) -> SyncConversationCursorPage[Project]
- client.admin.organization.projects.archive(project_id) -> Project
#### Users
Types:
```python
from openai.types.admin.organization.projects import ProjectUser, UserDeleteResponse
```
Methods:
- client.admin.organization.projects.users.create(project_id, \*\*params) -> ProjectUser
- client.admin.organization.projects.users.retrieve(user_id, \*, project_id) -> ProjectUser
- client.admin.organization.projects.users.update(user_id, \*, project_id, \*\*params) -> ProjectUser
- client.admin.organization.projects.users.list(project_id, \*\*params) -> SyncConversationCursorPage[ProjectUser]
- client.admin.organization.projects.users.delete(user_id, \*, project_id) -> UserDeleteResponse
##### Roles
Types:
```python
from openai.types.admin.organization.projects.users import (
RoleCreateResponse,
RoleRetrieveResponse,
RoleListResponse,
RoleDeleteResponse,
)
```
Methods:
- client.admin.organization.projects.users.roles.create(user_id, \*, project_id, \*\*params) -> RoleCreateResponse
- client.admin.organization.projects.users.roles.retrieve(role_id, \*, project_id, user_id) -> RoleRetrieveResponse
- client.admin.organization.projects.users.roles.list(user_id, \*, project_id, \*\*params) -> SyncNextCursorPage[RoleListResponse]
- client.admin.organization.projects.users.roles.delete(role_id, \*, project_id, user_id) -> RoleDeleteResponse
#### ServiceAccounts
Types:
```python
from openai.types.admin.organization.projects import (
ProjectServiceAccount,
ServiceAccountCreateResponse,
ServiceAccountDeleteResponse,
)
```
Methods:
- client.admin.organization.projects.service_accounts.create(project_id, \*\*params) -> ServiceAccountCreateResponse
- client.admin.organization.projects.service_accounts.retrieve(service_account_id, \*, project_id) -> ProjectServiceAccount
- client.admin.organization.projects.service_accounts.update(service_account_id, \*, project_id, \*\*params) -> ProjectServiceAccount
- client.admin.organization.projects.service_accounts.list(project_id, \*\*params) -> SyncConversationCursorPage[ProjectServiceAccount]
- client.admin.organization.projects.service_accounts.delete(service_account_id, \*, project_id) -> ServiceAccountDeleteResponse
##### APIKeys
Types:
```python
from openai.types.admin.organization.projects.service_accounts import APIKeyCreateResponse
```
Methods:
- client.admin.organization.projects.service_accounts.api_keys.create(service_account_id, \*, project_id, \*\*params) -> APIKeyCreateResponse
#### APIKeys
Types:
```python
from openai.types.admin.organization.projects import ProjectAPIKey, APIKeyDeleteResponse
```
Methods:
- client.admin.organization.projects.api_keys.retrieve(api_key_id, \*, project_id) -> ProjectAPIKey
- client.admin.organization.projects.api_keys.update(api_key_id, \*, project_id, \*\*params) -> ProjectAPIKey
- client.admin.organization.projects.api_keys.list(project_id, \*\*params) -> SyncConversationCursorPage[ProjectAPIKey]
- client.admin.organization.projects.api_keys.delete(api_key_id, \*, project_id) -> APIKeyDeleteResponse
#### RateLimits
Types:
```python
from openai.types.admin.organization.projects import ProjectRateLimit
```
Methods:
- client.admin.organization.projects.rate_limits.list_rate_limits(project_id, \*\*params) -> SyncConversationCursorPage[ProjectRateLimit]
- client.admin.organization.projects.rate_limits.update_rate_limit(rate_limit_id, \*, project_id, \*\*params) -> ProjectRateLimit
#### ModelPermissions
Types:
```python
from openai.types.admin.organization.projects import (
ProjectModelPermissions,
ProjectModelPermissionsDeleted,
)
```
Methods:
- client.admin.organization.projects.model_permissions.retrieve(project_id) -> ProjectModelPermissions
- client.admin.organization.projects.model_permissions.update(project_id, \*\*params) -> ProjectModelPermissions
- client.admin.organization.projects.model_permissions.delete(project_id) -> ProjectModelPermissionsDeleted
#### HostedToolPermissions
Types:
```python
from openai.types.admin.organization.projects import ProjectHostedToolPermissions
```
Methods:
- client.admin.organization.projects.hosted_tool_permissions.retrieve(project_id) -> ProjectHostedToolPermissions
- client.admin.organization.projects.hosted_tool_permissions.update(project_id, \*\*params) -> ProjectHostedToolPermissions
#### Groups
Types:
```python
from openai.types.admin.organization.projects import ProjectGroup, GroupDeleteResponse
```
Methods:
- client.admin.organization.projects.groups.create(project_id, \*\*params) -> ProjectGroup
- client.admin.organization.projects.groups.retrieve(group_id, \*, project_id, \*\*params) -> ProjectGroup
- client.admin.organization.projects.groups.list(project_id, \*\*params) -> SyncNextCursorPage[ProjectGroup]
- client.admin.organization.projects.groups.delete(group_id, \*, project_id) -> GroupDeleteResponse
##### Roles
Types:
```python
from openai.types.admin.organization.projects.groups import (
RoleCreateResponse,
RoleRetrieveResponse,
RoleListResponse,
RoleDeleteResponse,
)
```
Methods:
- client.admin.organization.projects.groups.roles.create(group_id, \*, project_id, \*\*params) -> RoleCreateResponse
- client.admin.organization.projects.groups.roles.retrieve(role_id, \*, project_id, group_id) -> RoleRetrieveResponse
- client.admin.organization.projects.groups.roles.list(group_id, \*, project_id, \*\*params) -> SyncNextCursorPage[RoleListResponse]
- client.admin.organization.projects.groups.roles.delete(role_id, \*, project_id, group_id) -> RoleDeleteResponse
#### Roles
Types:
```python
from openai.types.admin.organization.projects import RoleDeleteResponse
```
Methods:
- client.admin.organization.projects.roles.create(project_id, \*\*params) -> Role
- client.admin.organization.projects.roles.retrieve(role_id, \*, project_id) -> Role
- client.admin.organization.projects.roles.update(role_id, \*, project_id, \*\*params) -> Role
- client.admin.organization.projects.roles.list(project_id, \*\*params) -> SyncNextCursorPage[Role]
- client.admin.organization.projects.roles.delete(role_id, \*, project_id) -> RoleDeleteResponse
#### DataRetention
Types:
```python
from openai.types.admin.organization.projects import ProjectDataRetention
```
Methods:
- client.admin.organization.projects.data_retention.retrieve(project_id) -> ProjectDataRetention
- client.admin.organization.projects.data_retention.update(project_id, \*\*params) -> ProjectDataRetention
#### SpendLimit
Types:
```python
from openai.types.admin.organization.projects import ProjectSpendLimit, ProjectSpendLimitDeleted
```
Methods:
- client.admin.organization.projects.spend_limit.retrieve(project_id) -> ProjectSpendLimit
- client.admin.organization.projects.spend_limit.update(project_id, \*\*params) -> ProjectSpendLimit
- client.admin.organization.projects.spend_limit.delete(project_id) -> ProjectSpendLimitDeleted
#### SpendAlerts
Types:
```python
from openai.types.admin.organization.projects import ProjectSpendAlert, ProjectSpendAlertDeleted
```
Methods:
- client.admin.organization.projects.spend_alerts.create(project_id, \*\*params) -> ProjectSpendAlert
- client.admin.organization.projects.spend_alerts.retrieve(alert_id, \*, project_id) -> ProjectSpendAlert
- client.admin.organization.projects.spend_alerts.update(alert_id, \*, project_id, \*\*params) -> ProjectSpendAlert
- client.admin.organization.projects.spend_alerts.list(project_id, \*\*params) -> SyncConversationCursorPage[ProjectSpendAlert]
- client.admin.organization.projects.spend_alerts.delete(alert_id, \*, project_id) -> ProjectSpendAlertDeleted
#### Certificates
Types:
```python
from openai.types.admin.organization.projects import (
CertificateListResponse,
CertificateActivateResponse,
CertificateDeactivateResponse,
)
```
Methods:
- client.admin.organization.projects.certificates.list(project_id, \*\*params) -> SyncConversationCursorPage[CertificateListResponse]
- client.admin.organization.projects.certificates.activate(project_id, \*\*params) -> SyncPage[CertificateActivateResponse]
- client.admin.organization.projects.certificates.deactivate(project_id, \*\*params) -> SyncPage[CertificateDeactivateResponse]
# [Responses](src/openai/resources/responses/api.md)
# [Live](src/openai/resources/live/api.md)
# [Realtime](src/openai/resources/realtime/api.md)
# [Conversations](src/openai/resources/conversations/api.md)
# Evals
Types:
```python
from openai.types import (
EvalCustomDataSourceConfig,
EvalStoredCompletionsDataSourceConfig,
EvalCreateResponse,
EvalRetrieveResponse,
EvalUpdateResponse,
EvalListResponse,
EvalDeleteResponse,
)
```
Methods:
- client.evals.create(\*\*params) -> EvalCreateResponse
- client.evals.retrieve(eval_id) -> EvalRetrieveResponse
- client.evals.update(eval_id, \*\*params) -> EvalUpdateResponse
- client.evals.list(\*\*params) -> SyncCursorPage[EvalListResponse]
- client.evals.delete(eval_id) -> EvalDeleteResponse
## Runs
Types:
```python
from openai.types.evals import (
CreateEvalCompletionsRunDataSource,
CreateEvalJSONLRunDataSource,
EvalAPIError,
RunCreateResponse,
RunRetrieveResponse,
RunListResponse,
RunDeleteResponse,
RunCancelResponse,
)
```
Methods:
- client.evals.runs.create(eval_id, \*\*params) -> RunCreateResponse
- client.evals.runs.retrieve(run_id, \*, eval_id) -> RunRetrieveResponse
- client.evals.runs.list(eval_id, \*\*params) -> SyncCursorPage[RunListResponse]
- client.evals.runs.delete(run_id, \*, eval_id) -> RunDeleteResponse
- client.evals.runs.cancel(run_id, \*, eval_id) -> RunCancelResponse
### OutputItems
Types:
```python
from openai.types.evals.runs import OutputItemRetrieveResponse, OutputItemListResponse
```
Methods:
- client.evals.runs.output_items.retrieve(output_item_id, \*, eval_id, run_id) -> OutputItemRetrieveResponse
- client.evals.runs.output_items.list(run_id, \*, eval_id, \*\*params) -> SyncCursorPage[OutputItemListResponse]
# Containers
Types:
```python
from openai.types import ContainerCreateResponse, ContainerRetrieveResponse, ContainerListResponse
```
Methods:
- client.containers.create(\*\*params) -> ContainerCreateResponse
- client.containers.retrieve(container_id) -> ContainerRetrieveResponse
- client.containers.list(\*\*params) -> SyncCursorPage[ContainerListResponse]
- client.containers.delete(container_id) -> None
## Files
Types:
```python
from openai.types.containers import FileCreateResponse, FileRetrieveResponse, FileListResponse
```
Methods:
- client.containers.files.create(container_id, \*\*params) -> FileCreateResponse
- client.containers.files.retrieve(file_id, \*, container_id) -> FileRetrieveResponse
- client.containers.files.list(container_id, \*\*params) -> SyncCursorPage[FileListResponse]
- client.containers.files.delete(file_id, \*, container_id) -> None
### Content
Methods:
- client.containers.files.content.retrieve(file_id, \*, container_id) -> HttpxBinaryResponseContent
# Skills
Types:
```python
from openai.types import DeletedSkill, Skill, SkillList
```
Methods:
- client.skills.create(\*\*params) -> Skill
- client.skills.retrieve(skill_id) -> Skill
- client.skills.update(skill_id, \*\*params) -> Skill
- client.skills.list(\*\*params) -> SyncCursorPage[Skill]
- client.skills.delete(skill_id) -> DeletedSkill
## Content
Methods:
- client.skills.content.retrieve(skill_id) -> HttpxBinaryResponseContent
## Versions
Types:
```python
from openai.types.skills import DeletedSkillVersion, SkillVersion, SkillVersionList
```
Methods:
- client.skills.versions.create(skill_id, \*\*params) -> SkillVersion
- client.skills.versions.retrieve(version, \*, skill_id) -> SkillVersion
- client.skills.versions.list(skill_id, \*\*params) -> SyncCursorPage[SkillVersion]
- client.skills.versions.delete(version, \*, skill_id) -> DeletedSkillVersion
### Content
Methods:
- client.skills.versions.content.retrieve(version, \*, skill_id) -> HttpxBinaryResponseContent
# Videos
Types:
```python
from openai.types import (
ImageInputReferenceParam,
Video,
VideoCreateError,
VideoModel,
VideoSeconds,
VideoSize,
VideoDeleteResponse,
VideoCreateCharacterResponse,
VideoGetCharacterResponse,
)
```
Methods:
- client.videos.create(\*\*params) -> Video
- client.videos.retrieve(video_id) -> Video
- client.videos.list(\*\*params) -> SyncConversationCursorPage[Video]
- client.videos.delete(video_id) -> VideoDeleteResponse
- client.videos.create_character(\*\*params) -> VideoCreateCharacterResponse
- client.videos.download_content(video_id, \*\*params) -> HttpxBinaryResponseContent
- client.videos.edit(\*\*params) -> Video
- client.videos.extend(\*\*params) -> Video
- client.videos.get_character(character_id) -> VideoGetCharacterResponse
- client.videos.remix(video_id, \*\*params) -> Video
- client.videos.create_and_poll(\*, prompt, input_reference=..., model=..., seconds=..., size=..., poll_interval_ms=..., extra_headers=..., extra_query=..., extra_body=..., timeout=...) -> Video
- client.videos.poll(video_id, \*, poll_interval_ms=...) -> Video