# Shared Types
```python
from openai.types import (
AllModels,
ChatModel,
ComparisonFilter,
CompoundFilter,
CustomToolInputFormat,
ErrorObject,
FunctionDefinition,
FunctionParameters,
Metadata,
Reasoning,
ReasoningEffort,
ResponseFormatJSONObject,
ResponseFormatJSONSchema,
ResponseFormatText,
ResponseFormatTextGrammar,
ResponseFormatTextPython,
ResponsesModel,
)
```
# 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 (
ChatCompletion,
ChatCompletionAllowedToolChoice,
ChatCompletionAssistantMessageParam,
ChatCompletionAudio,
ChatCompletionAudioParam,
ChatCompletionChunk,
ChatCompletionContentPart,
ChatCompletionContentPartImage,
ChatCompletionContentPartInputAudio,
ChatCompletionContentPartRefusal,
ChatCompletionContentPartText,
ChatCompletionCustomTool,
ChatCompletionDeleted,
ChatCompletionDeveloperMessageParam,
ChatCompletionFunctionCallOption,
ChatCompletionFunctionMessageParam,
ChatCompletionFunctionTool,
ChatCompletionMessage,
ChatCompletionMessageCustomToolCall,
ChatCompletionMessageFunctionToolCall,
ChatCompletionMessageParam,
ChatCompletionMessageToolCallUnion,
ChatCompletionModality,
ChatCompletionNamedToolChoice,
ChatCompletionNamedToolChoiceCustom,
ChatCompletionPredictionContent,
ChatCompletionRole,
ChatCompletionStoreMessage,
ChatCompletionStreamOptions,
ChatCompletionSystemMessageParam,
ChatCompletionTokenLogprob,
ChatCompletionToolUnion,
ChatCompletionToolChoiceOption,
ChatCompletionToolMessageParam,
ChatCompletionUserMessageParam,
ChatCompletionAllowedTools,
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
### 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(\*args) -> 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
# Audio
Types:
```python
from openai.types import AudioModel, AudioResponseFormat
```
## Transcriptions
Types:
```python
from openai.types.audio import (
Transcription,
TranscriptionDiarized,
TranscriptionDiarizedSegment,
TranscriptionInclude,
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
# Moderations
Types:
```python
from openai.types import (
Moderation,
ModerationImageURLInput,
ModerationModel,
ModerationMultiModalInput,
ModerationTextInput,
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,
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.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(\*args) -> VectorStoreFile
- client.vector_stores.files.poll(\*args) -> VectorStoreFile
- client.vector_stores.files.upload(\*args) -> VectorStoreFile
- client.vector_stores.files.upload_and_poll(\*args) -> 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(\*args) -> VectorStoreFileBatch
- client.vector_stores.file_batches.poll(\*args) -> VectorStoreFileBatch
- client.vector_stores.file_batches.upload_and_poll(\*args) -> VectorStoreFileBatch
# Webhooks
Types:
```python
from openai.types.webhooks import (
BatchCancelledWebhookEvent,
BatchCompletedWebhookEvent,
BatchExpiredWebhookEvent,
BatchFailedWebhookEvent,
EvalRunCanceledWebhookEvent,
EvalRunFailedWebhookEvent,
EvalRunSucceededWebhookEvent,
FineTuningJobCancelledWebhookEvent,
FineTuningJobFailedWebhookEvent,
FineTuningJobSucceededWebhookEvent,
RealtimeCallIncomingWebhookEvent,
ResponseCancelledWebhookEvent,
ResponseCompletedWebhookEvent,
ResponseFailedWebhookEvent,
ResponseIncompleteWebhookEvent,
UnwrapWebhookEvent,
)
```
Methods:
- client.webhooks.unwrap(payload, headers, \*, secret) -> UnwrapWebhookEvent
- client.webhooks.verify_signature(payload, headers, \*, secret, tolerance) -> None
# Beta
## Realtime
Types:
```python
from openai.types.beta.realtime import (
ConversationCreatedEvent,
ConversationItem,
ConversationItemContent,
ConversationItemCreateEvent,
ConversationItemCreatedEvent,
ConversationItemDeleteEvent,
ConversationItemDeletedEvent,
ConversationItemInputAudioTranscriptionCompletedEvent,
ConversationItemInputAudioTranscriptionDeltaEvent,
ConversationItemInputAudioTranscriptionFailedEvent,
ConversationItemRetrieveEvent,
ConversationItemTruncateEvent,
ConversationItemTruncatedEvent,
ConversationItemWithReference,
ErrorEvent,
InputAudioBufferAppendEvent,
InputAudioBufferClearEvent,
InputAudioBufferClearedEvent,
InputAudioBufferCommitEvent,
InputAudioBufferCommittedEvent,
InputAudioBufferSpeechStartedEvent,
InputAudioBufferSpeechStoppedEvent,
RateLimitsUpdatedEvent,
RealtimeClientEvent,
RealtimeResponse,
RealtimeResponseStatus,
RealtimeResponseUsage,
RealtimeServerEvent,
ResponseAudioDeltaEvent,
ResponseAudioDoneEvent,
ResponseAudioTranscriptDeltaEvent,
ResponseAudioTranscriptDoneEvent,
ResponseCancelEvent,
ResponseContentPartAddedEvent,
ResponseContentPartDoneEvent,
ResponseCreateEvent,
ResponseCreatedEvent,
ResponseDoneEvent,
ResponseFunctionCallArgumentsDeltaEvent,
ResponseFunctionCallArgumentsDoneEvent,
ResponseOutputItemAddedEvent,
ResponseOutputItemDoneEvent,
ResponseTextDeltaEvent,
ResponseTextDoneEvent,
SessionCreatedEvent,
SessionUpdateEvent,
SessionUpdatedEvent,
TranscriptionSessionUpdate,
TranscriptionSessionUpdatedEvent,
)
```
### Sessions
Types:
```python
from openai.types.beta.realtime import Session, SessionCreateResponse
```
Methods:
- client.beta.realtime.sessions.create(\*\*params) -> SessionCreateResponse
### TranscriptionSessions
Types:
```python
from openai.types.beta.realtime import TranscriptionSession
```
Methods:
- client.beta.realtime.transcription_sessions.create(\*\*params) -> TranscriptionSession
## Assistants
Types:
```python
from openai.types.beta import (
Assistant,
AssistantDeleted,
AssistantStreamEvent,
AssistantTool,
CodeInterpreterTool,
FileSearchTool,
FunctionTool,
MessageStreamEvent,
RunStepStreamEvent,
RunStreamEvent,
ThreadStreamEvent,
)
```
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(\*args) -> Run
- client.beta.threads.create_and_run_stream(\*args) -> 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(\*args) -> Run
- client.beta.threads.runs.create_and_stream(\*args) -> AssistantStreamManager[AssistantEventHandler] | AssistantStreamManager[AssistantEventHandlerT]
- client.beta.threads.runs.poll(\*args) -> Run
- client.beta.threads.runs.stream(\*args) -> AssistantStreamManager[AssistantEventHandler] | AssistantStreamManager[AssistantEventHandlerT]
- client.beta.threads.runs.submit_tool_outputs_and_poll(\*args) -> Run
- client.beta.threads.runs.submit_tool_outputs_stream(\*args) -> 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
## Parts
Types:
```python
from openai.types.uploads import UploadPart
```
Methods:
- client.uploads.parts.create(upload_id, \*\*params) -> UploadPart
# Responses
Types:
```python
from openai.types.responses import (
ApplyPatchTool,
CompactedResponse,
ComputerTool,
CustomTool,
EasyInputMessage,
FileSearchTool,
FunctionShellTool,
FunctionTool,
Response,
ResponseApplyPatchToolCall,
ResponseApplyPatchToolCallOutput,
ResponseAudioDeltaEvent,
ResponseAudioDoneEvent,
ResponseAudioTranscriptDeltaEvent,
ResponseAudioTranscriptDoneEvent,
ResponseCodeInterpreterCallCodeDeltaEvent,
ResponseCodeInterpreterCallCodeDoneEvent,
ResponseCodeInterpreterCallCompletedEvent,
ResponseCodeInterpreterCallInProgressEvent,
ResponseCodeInterpreterCallInterpretingEvent,
ResponseCodeInterpreterToolCall,
ResponseCompactionItem,
ResponseCompactionItemParam,
ResponseCompletedEvent,
ResponseComputerToolCall,
ResponseComputerToolCallOutputItem,
ResponseComputerToolCallOutputScreenshot,
ResponseContent,
ResponseContentPartAddedEvent,
ResponseContentPartDoneEvent,
ResponseConversationParam,
ResponseCreatedEvent,
ResponseCustomToolCall,
ResponseCustomToolCallInputDeltaEvent,
ResponseCustomToolCallInputDoneEvent,
ResponseCustomToolCallOutput,
ResponseError,
ResponseErrorEvent,
ResponseFailedEvent,
ResponseFileSearchCallCompletedEvent,
ResponseFileSearchCallInProgressEvent,
ResponseFileSearchCallSearchingEvent,
ResponseFileSearchToolCall,
ResponseFormatTextConfig,
ResponseFormatTextJSONSchemaConfig,
ResponseFunctionCallArgumentsDeltaEvent,
ResponseFunctionCallArgumentsDoneEvent,
ResponseFunctionCallOutputItem,
ResponseFunctionCallOutputItemList,
ResponseFunctionShellCallOutputContent,
ResponseFunctionShellToolCall,
ResponseFunctionShellToolCallOutput,
ResponseFunctionToolCall,
ResponseFunctionToolCallItem,
ResponseFunctionToolCallOutputItem,
ResponseFunctionWebSearch,
ResponseImageGenCallCompletedEvent,
ResponseImageGenCallGeneratingEvent,
ResponseImageGenCallInProgressEvent,
ResponseImageGenCallPartialImageEvent,
ResponseInProgressEvent,
ResponseIncludable,
ResponseIncompleteEvent,
ResponseInput,
ResponseInputAudio,
ResponseInputContent,
ResponseInputFile,
ResponseInputFileContent,
ResponseInputImage,
ResponseInputImageContent,
ResponseInputItem,
ResponseInputMessageContentList,
ResponseInputMessageItem,
ResponseInputText,
ResponseInputTextContent,
ResponseItem,
ResponseMcpCallArgumentsDeltaEvent,
ResponseMcpCallArgumentsDoneEvent,
ResponseMcpCallCompletedEvent,
ResponseMcpCallFailedEvent,
ResponseMcpCallInProgressEvent,
ResponseMcpListToolsCompletedEvent,
ResponseMcpListToolsFailedEvent,
ResponseMcpListToolsInProgressEvent,
ResponseOutputAudio,
ResponseOutputItem,
ResponseOutputItemAddedEvent,
ResponseOutputItemDoneEvent,
ResponseOutputMessage,
ResponseOutputRefusal,
ResponseOutputText,
ResponseOutputTextAnnotationAddedEvent,
ResponsePrompt,
ResponseQueuedEvent,
ResponseReasoningItem,
ResponseReasoningSummaryPartAddedEvent,
ResponseReasoningSummaryPartDoneEvent,
ResponseReasoningSummaryTextDeltaEvent,
ResponseReasoningSummaryTextDoneEvent,
ResponseReasoningTextDeltaEvent,
ResponseReasoningTextDoneEvent,
ResponseRefusalDeltaEvent,
ResponseRefusalDoneEvent,
ResponseStatus,
ResponseStreamEvent,
ResponseTextConfig,
ResponseTextDeltaEvent,
ResponseTextDoneEvent,
ResponseUsage,
ResponseWebSearchCallCompletedEvent,
ResponseWebSearchCallInProgressEvent,
ResponseWebSearchCallSearchingEvent,
Tool,
ToolChoiceAllowed,
ToolChoiceApplyPatch,
ToolChoiceCustom,
ToolChoiceFunction,
ToolChoiceMcp,
ToolChoiceOptions,
ToolChoiceShell,
ToolChoiceTypes,
WebSearchPreviewTool,
WebSearchTool,
)
```
Methods:
- client.responses.create(\*\*params) -> Response
- client.responses.retrieve(response_id, \*\*params) -> Response
- client.responses.delete(response_id) -> None
- client.responses.cancel(response_id) -> Response
- client.responses.compact(\*\*params) -> CompactedResponse
## InputItems
Types:
```python
from openai.types.responses import ResponseItemList
```
Methods:
- client.responses.input_items.list(response_id, \*\*params) -> SyncCursorPage[ResponseItem]
## InputTokens
Types:
```python
from openai.types.responses import InputTokenCountResponse
```
Methods:
- client.responses.input_tokens.count(\*\*params) -> InputTokenCountResponse
# Realtime
Types:
```python
from openai.types.realtime import (
AudioTranscription,
ConversationCreatedEvent,
ConversationItem,
ConversationItemAdded,
ConversationItemCreateEvent,
ConversationItemCreatedEvent,
ConversationItemDeleteEvent,
ConversationItemDeletedEvent,
ConversationItemDone,
ConversationItemInputAudioTranscriptionCompletedEvent,
ConversationItemInputAudioTranscriptionDeltaEvent,
ConversationItemInputAudioTranscriptionFailedEvent,
ConversationItemInputAudioTranscriptionSegment,
ConversationItemRetrieveEvent,
ConversationItemTruncateEvent,
ConversationItemTruncatedEvent,
ConversationItemWithReference,
InputAudioBufferAppendEvent,
InputAudioBufferClearEvent,
InputAudioBufferClearedEvent,
InputAudioBufferCommitEvent,
InputAudioBufferCommittedEvent,
InputAudioBufferDtmfEventReceivedEvent,
InputAudioBufferSpeechStartedEvent,
InputAudioBufferSpeechStoppedEvent,
InputAudioBufferTimeoutTriggered,
LogProbProperties,
McpListToolsCompleted,
McpListToolsFailed,
McpListToolsInProgress,
NoiseReductionType,
OutputAudioBufferClearEvent,
RateLimitsUpdatedEvent,
RealtimeAudioConfig,
RealtimeAudioConfigInput,
RealtimeAudioConfigOutput,
RealtimeAudioFormats,
RealtimeAudioInputTurnDetection,
RealtimeClientEvent,
RealtimeConversationItemAssistantMessage,
RealtimeConversationItemFunctionCall,
RealtimeConversationItemFunctionCallOutput,
RealtimeConversationItemSystemMessage,
RealtimeConversationItemUserMessage,
RealtimeError,
RealtimeErrorEvent,
RealtimeFunctionTool,
RealtimeMcpApprovalRequest,
RealtimeMcpApprovalResponse,
RealtimeMcpListTools,
RealtimeMcpProtocolError,
RealtimeMcpToolCall,
RealtimeMcpToolExecutionError,
RealtimeMcphttpError,
RealtimeResponse,
RealtimeResponseCreateAudioOutput,
RealtimeResponseCreateMcpTool,
RealtimeResponseCreateParams,
RealtimeResponseStatus,
RealtimeResponseUsage,
RealtimeResponseUsageInputTokenDetails,
RealtimeResponseUsageOutputTokenDetails,
RealtimeServerEvent,
RealtimeSession,
RealtimeSessionCreateRequest,
RealtimeToolChoiceConfig,
RealtimeToolsConfig,
RealtimeToolsConfigUnion,
RealtimeTracingConfig,
RealtimeTranscriptionSessionAudio,
RealtimeTranscriptionSessionAudioInput,
RealtimeTranscriptionSessionAudioInputTurnDetection,
RealtimeTranscriptionSessionCreateRequest,
RealtimeTruncation,
RealtimeTruncationRetentionRatio,
ResponseAudioDeltaEvent,
ResponseAudioDoneEvent,
ResponseAudioTranscriptDeltaEvent,
ResponseAudioTranscriptDoneEvent,
ResponseCancelEvent,
ResponseContentPartAddedEvent,
ResponseContentPartDoneEvent,
ResponseCreateEvent,
ResponseCreatedEvent,
ResponseDoneEvent,
ResponseFunctionCallArgumentsDeltaEvent,
ResponseFunctionCallArgumentsDoneEvent,
ResponseMcpCallArgumentsDelta,
ResponseMcpCallArgumentsDone,
ResponseMcpCallCompleted,
ResponseMcpCallFailed,
ResponseMcpCallInProgress,
ResponseOutputItemAddedEvent,
ResponseOutputItemDoneEvent,
ResponseTextDeltaEvent,
ResponseTextDoneEvent,
SessionCreatedEvent,
SessionUpdateEvent,
SessionUpdatedEvent,
TranscriptionSessionUpdate,
TranscriptionSessionUpdatedEvent,
)
```
## ClientSecrets
Types:
```python
from openai.types.realtime import (
RealtimeSessionClientSecret,
RealtimeSessionCreateResponse,
RealtimeTranscriptionSessionCreateResponse,
RealtimeTranscriptionSessionTurnDetection,
ClientSecretCreateResponse,
)
```
Methods:
- client.realtime.client_secrets.create(\*\*params) -> ClientSecretCreateResponse
## Calls
Methods:
- client.realtime.calls.create(\*\*params) -> HttpxBinaryResponseContent
- client.realtime.calls.accept(call_id, \*\*params) -> None
- client.realtime.calls.hangup(call_id) -> None
- client.realtime.calls.refer(call_id, \*\*params) -> None
- client.realtime.calls.reject(call_id, \*\*params) -> None
# Conversations
Types:
```python
from openai.types.conversations import (
ComputerScreenshotContent,
Conversation,
ConversationDeleted,
ConversationDeletedResource,
Message,
SummaryTextContent,
TextContent,
InputTextContent,
OutputTextContent,
RefusalContent,
InputImageContent,
InputFileContent,
)
```
Methods:
- client.conversations.create(\*\*params) -> Conversation
- client.conversations.retrieve(conversation_id) -> Conversation
- client.conversations.update(conversation_id, \*\*params) -> Conversation
- client.conversations.delete(conversation_id) -> ConversationDeletedResource
## Items
Types:
```python
from openai.types.conversations import ConversationItem, ConversationItemList
```
Methods:
- client.conversations.items.create(conversation_id, \*\*params) -> ConversationItemList
- client.conversations.items.retrieve(item_id, \*, conversation_id, \*\*params) -> ConversationItem
- client.conversations.items.list(conversation_id, \*\*params) -> SyncConversationCursorPage[ConversationItem]
- client.conversations.items.delete(item_id, \*, conversation_id) -> Conversation
# 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
# Videos
Types:
```python
from openai.types import (
Video,
VideoCreateError,
VideoModel,
VideoSeconds,
VideoSize,
VideoDeleteResponse,
)
```
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.download_content(video_id, \*\*params) -> HttpxBinaryResponseContent
- client.videos.remix(video_id, \*\*params) -> Video
- client.videos.create_and_poll(\*args) -> Video