Skip to content
For the complete documentation index, see llms.txt. Markdown versions of documentation pages are available by appending .md to the page URL.
Primary navigation

Suggested
Overview Models Agents Tools Audio & voice Production API reference

Beta

BetaAgents

Create an agent
client.Beta.Agents.New(ctx, body) (*Agent, error)
POST
/agents
Delete an agent
client.Beta.Agents.Delete(ctx, agentID) (*AgentDeleted, error)
DELETE
/agents/{agent_id}
List agents
client.Beta.Agents.List(ctx, query) (*CursorPage[Agent], error)
GET
/agents
Retrieve an agent
client.Beta.Agents.Get(ctx, agentID) (*Agent, error)
GET
/agents/{agent_id}
Update an agent
client.Beta.Agents.Update(ctx, agentID, body) (*Agent, error)
POST
/agents/{agent_id}
Models
type Agent struct{…}

A reusable agent scoped to the caller’s project.

type AgentBrowserAuthenticationCancelParamResp struct{…}
type AgentBrowserAuthenticationSubmitParamResp struct{…}
type AgentBrowserOriginAccessParamResp struct{…}
type AgentCloseSubagentCallItem struct{…}

A request to close a subagent.

type AgentCommandExecutionItem struct{…}

A command execution produced by the agent.

type AgentContentUnion interface{…}

A plaintext or encrypted content part exchanged between agents.

type AgentCreateSubagentCallItem struct{…}

A request to spawn a subagent.

type AgentDeleted struct{…}

A deleted reusable agent.

type AgentFunctionCallItem struct{…}

A function call produced by the agent.

type AgentFunctionCallOutputUnion interface{…}

The text or model-input content supplied as a function result.

type AgentFunctionCallOutputParamUnionResp interface{…}

A function result represented as text or supported model-input content.

type AgentFunctionCallStatus string

The status of a tool call.

type AgentInterruptSubagentCallItem struct{…}

A request to interrupt a subagent’s current turn. The subagent remains available.

type AgentMcpCallItem struct{…}

A call to a tool on an MCP server.

type AgentOutputCommandExecutionOutputDeltaEvent struct{…}

Emitted when command execution produces an output delta.

type AgentOutputItemUnion interface{…}

An output item produced by an agent.

type AgentOutputItemStatus string

The status of an agent output item.

type AgentReasoning struct{…}

The reasoning configuration used by an agent.

type AgentReasoningItem struct{…}

A reasoning item produced by the agent.

type AgentReasoningParamResp struct{…}

Reasoning configuration for the agent.

type AgentResumeSubagentCallItem struct{…}

A request to resume a subagent.

type AgentSendSubagentInputCallItem struct{…}

A request to send input to another agent.

type AgentSession struct{…}

A Managed Agents session.

type AgentSessionAssistantMessage struct{…}

An assistant message produced by the agent.

type AgentSessionCreatedEvent struct{…}

Emitted when a session is created.

type AgentSessionDeleted struct{…}

A Managed Agents session removed from the public API. Physical cleanup may continue asynchronously.

type AgentSessionEnvironmentConnectedEvent struct{…}

Emitted when a session environment connects.

type AgentSessionEnvironmentDisconnectedEvent struct{…}

Emitted when a session environment disconnects.

type AgentSessionEnvironmentExpiredEvent struct{…}

Emitted after a suspended hosted session environment and its checkpoint expire.

type AgentSessionEnvironmentFailedEvent struct{…}

Emitted when a session environment fails.

type AgentSessionEnvironmentPendingEvent struct{…}

Emitted while a session environment is being prepared.

type AgentSessionEnvironmentReadyEvent struct{…}

Emitted when a hosted session environment is ready to connect.

type AgentSessionEnvironmentResetEvent struct{…}

Emitted after a hosted sandbox is replaced. Conversation history survives; changes to the previous sandbox’s files and processes do not.

type AgentSessionEnvironmentState struct{…}

The current state of a session environment.

type AgentSessionEnvironmentSuspendedEvent struct{…}

Emitted after an idle hosted session environment is checkpointed and stopped.

type AgentSessionErrorEvent struct{…}

Emitted when a turn or session fails.

type AgentSessionEventUnion interface{…}

An event emitted by a Managed Agents session.

type AgentSessionFailedEvent struct{…}

Emitted when a session fails.

type AgentSessionIdleEvent struct{…}

Emitted when a session becomes idle.

type AgentSessionInProgressEvent struct{…}

Emitted when a session starts processing a turn.

type AgentSessionInputMessageParamResp struct{…}

A user message submitted to a session.

type AgentSessionInputParamUnionResp interface{…}

Input submitted to an existing session.

type AgentSessionItemUnion interface{…}

An item associated with a session turn.

type AgentSessionMessage struct{…}

A user or assistant message recorded in a session.

type AgentSessionMessageContentUnion interface{…}

A content part in a session message.

type AgentSessionRequiresActionEvent struct{…}

Emitted when a session is waiting for one or more required actions.

type AgentSessionSubagentActiveEvent struct{…}

Emitted when a closed subagent successfully resumes.

type AgentSessionSubagentClosedEvent struct{…}

Emitted when a subagent is closed.

type AgentSessionSubagentCreatedEvent struct{…}

Emitted when a subagent is created.

type AgentSessionTurnCancelledEvent struct{…}

Emitted when a turn is cancelled.

type AgentSessionTurnCompletedEvent struct{…}

Emitted when a turn completes.

type AgentSessionTurnContentPartAddedEvent struct{…}

Emitted when an output text content part is added.

type AgentSessionTurnContentPartDoneEvent struct{…}

Emitted when an output content part is complete.

type AgentSessionTurnCreatedEvent struct{…}

Emitted when a turn is created.

type AgentSessionTurnFailedEvent struct{…}

Emitted when a turn fails.

type AgentSessionTurnInProgressEvent struct{…}

Emitted when a turn starts running.

type AgentSessionTurnItemAddedEvent struct{…}

Emitted when an item is added to a turn.

type AgentSessionTurnItemDoneEvent struct{…}

Emitted when an output item is complete.

type AgentSessionTurnOutputTextDeltaEvent struct{…}

Emitted when text is appended to an output text content part.

type AgentSessionTurnOutputTextDoneEvent struct{…}

Emitted when an output text content part is complete.

type AgentSessionTurnReasoningSummaryPartAddedEvent struct{…}

Emitted when a reasoning summary content part is added.

type AgentSessionTurnReasoningSummaryPartDoneEvent struct{…}

Emitted when a reasoning summary part is complete.

type AgentSessionTurnReasoningSummaryTextDeltaEvent struct{…}

Emitted when text is appended to a reasoning summary.

type AgentSessionTurnReasoningSummaryTextDoneEvent struct{…}

Emitted when a reasoning summary content part is complete.

type AgentText struct{…}

The text configuration used by an agent.

type AgentTextParamResp struct{…}

Configuration for text generated by the agent.

type AgentToolUnion interface{…}

A tool available to the agent.

type AgentToolParamUnionResp interface{…}

A tool available to the agent.

type AgentWaitForSubagentsCallItem struct{…}

A request to wait for one or more subagents.

type AgentWebSearchCallItem struct{…}

A web search call produced by the agent.

type EnvironmentUnion interface{…}

The execution environment for a session.

type EnvironmentParamUnionResp interface{…}

The execution environment and optional reusable template for a session.

type HostedEnvironmentFileUnion interface{…}

Metadata for a file materialized in an OpenAI-hosted execution environment.

type HostedEnvironmentFileID struct{…}

A file copied from the OpenAI Files API.

type HostedEnvironmentFileParamUnionResp interface{…}

A file materialized in an OpenAI-hosted execution environment.

type HostedPlugin struct{…}

A plugin installed from an inline ZIP archive.

type HostedPluginParamResp struct{…}

Supplies a plugin ZIP directly in the session request.

type HostedSkillUnion interface{…}

A skill installed in an OpenAI-hosted environment.

type HostedSkillParamUnionResp interface{…}

A skill installed in an OpenAI-hosted environment.

type HostedSkillReference struct{…}

A skill installed from the Skills API.

type InlineCapabilitySourceParamResp struct{…}

Provides ZIP bytes encoded with standard base64.

type InputContentUnion interface{…}

User-provided content recorded in a session item.

type InputContentParamUnionResp interface{…}

Content included in an input message.

type McpTransportUnion interface{…}

The transport used to connect to an MCP server.

type McpTransportParamUnionResp interface{…}

The transport used to connect to an MCP server.

type MultiAgentConfig struct{…}

The resolved configuration for creating and coordinating subagents.

type MultiAgentConfigParamResp struct{…}

Explicit configuration for creating and coordinating subagents.

type OutputText struct{…}

A text content part produced by the agent.

type PersistedAgentToolUnion interface{…}

A credential-free tool available to a reusable agent.

type PersistedAgentToolParamUnionResp interface{…}

A tool that can be stored on a reusable agent without session credentials.

type PersistedMcpTransportUnion interface{…}

A credential-free transport used to connect to an MCP server.

type PersistedMcpTransportParamUnionResp interface{…}

A credential-free transport used to connect to an MCP server.

type SessionError struct{…}

An error payload with the same public fields as Responses API streaming errors.

type SessionTurnError struct{…}

A customer-safe error describing why a session request failed.

type SetupCommandParamResp struct{…}

A confidential setup command executed before the hosted agent starts.

type Subagent struct{…}

A subagent created within a session.

type SummaryText struct{…}

A reasoning summary content part.

type TextFormatUnion interface{…}

The effective output format for generated text.

type TextFormatParamUnionResp interface{…}

The output format for generated text.

type TokenUsage struct{…}

Recorded token usage for a session or turn. Usage is best effort and may change.

type WebSearchActionUnion interface{…}

An action performed by the web search tool.

BetaAgentsEnvironments

Create an agent environment
client.Beta.Agents.Environments.New(ctx, params) (*EnvironmentInfo, error)
POST
/agents/environments
List agent environments
client.Beta.Agents.Environments.List(ctx, query) (*CursorPage[EnvironmentInfo], error)
GET
/agents/environments
Retrieve an agent environment
client.Beta.Agents.Environments.Get(ctx, environmentID) (*EnvironmentInfo, error)
GET
/agents/environments/{environment_id}
Models
type EnvironmentInfo struct{…}

Safe metadata for a first-class execution environment.

BetaAgentsEnvironmentsFiles

Write an agent environment file
client.Beta.Agents.Environments.Files.New(ctx, environmentID, body) (*EnvironmentFile, error)
POST
/agents/environments/{environment_id}/files
List agent environment files
client.Beta.Agents.Environments.Files.List(ctx, environmentID, query) (*TokenPage[EnvironmentFile], error)
GET
/agents/environments/{environment_id}/files
Models
type EnvironmentFile struct{…}

A live file in an execution environment.

BetaAgentsEnvironmentsTemplates

Create an agent environment template
client.Beta.Agents.Environments.Templates.New(ctx, body) (*EnvironmentTemplate, error)
POST
/agents/environments/templates
Delete an agent environment template
client.Beta.Agents.Environments.Templates.Delete(ctx, environmentTemplateID) (*EnvironmentTemplateDeleted, error)
DELETE
/agents/environments/templates/{environment_template_id}
List agent environment templates
client.Beta.Agents.Environments.Templates.List(ctx, query) (*CursorPage[EnvironmentTemplate], error)
GET
/agents/environments/templates
Retrieve an agent environment template
client.Beta.Agents.Environments.Templates.Get(ctx, environmentTemplateID) (*EnvironmentTemplate, error)
GET
/agents/environments/templates/{environment_template_id}
Update an agent environment template
client.Beta.Agents.Environments.Templates.Update(ctx, environmentTemplateID, body) (*EnvironmentTemplate, error)
POST
/agents/environments/templates/{environment_template_id}
Models
type EnvironmentTemplate struct{…}

Reusable configuration that provisions a fresh OpenAI-hosted environment for each session.

type EnvironmentTemplateDeleted struct{…}

A deleted reusable environment template.

BetaAgentsSessions

Create an agent session
client.Beta.Agents.Sessions.New(ctx, body) (*AgentSession, error)
POST
/agents/sessions
Delete an agent session
client.Beta.Agents.Sessions.Delete(ctx, sessionID) (*AgentSessionDeleted, error)
DELETE
/agents/sessions/{session_id}
List agent sessions
client.Beta.Agents.Sessions.List(ctx, query) (*CursorPage[AgentSession], error)
GET
/agents/sessions
Retrieve an agent session
client.Beta.Agents.Sessions.Get(ctx, sessionID) (*AgentSession, error)
GET
/agents/sessions/{session_id}
Update an agent session
client.Beta.Agents.Sessions.Update(ctx, sessionID, body) (*AgentSession, error)
POST
/agents/sessions/{session_id}

BetaAgentsSessionsArtifacts

Retrieve agent session artifact content
client.Beta.Agents.Sessions.Artifacts.Content(ctx, sessionID, artifactID) (*Response, error)
GET
/agents/sessions/{session_id}/artifacts/{artifact_id}/content
Delete an agent session artifact
client.Beta.Agents.Sessions.Artifacts.Delete(ctx, sessionID, artifactID) (*SessionArtifactDeleted, error)
DELETE
/agents/sessions/{session_id}/artifacts/{artifact_id}
List agent session artifacts
client.Beta.Agents.Sessions.Artifacts.List(ctx, sessionID, query) (*CursorPage[SessionArtifact], error)
GET
/agents/sessions/{session_id}/artifacts
Retrieve an agent session artifact
client.Beta.Agents.Sessions.Artifacts.Get(ctx, sessionID, artifactID) (*SessionArtifact, error)
GET
/agents/sessions/{session_id}/artifacts/{artifact_id}
Models
type SessionArtifact struct{…}

An immutable file published by a completed hosted session turn.

type SessionArtifactDeleted struct{…}

Confirmation that an immutable session artifact was deleted.

BetaAgentsSessionsEvents

Create agent session input events
client.Beta.Agents.Sessions.Events.New(ctx, sessionID, params) error
POST
/agents/sessions/{session_id}/events
Stream agent session events
client.Beta.Agents.Sessions.Events.Stream(ctx, sessionID) (*AgentSessionEventUnion, error)
GET
/agents/sessions/{session_id}/events

BetaAgentsSessionsItems

List agent session items
client.Beta.Agents.Sessions.Items.List(ctx, sessionID, query) (*CursorPage[AgentSessionItemUnion], error)
GET
/agents/sessions/{session_id}/items

BetaAgentsSessionsSubagents

List session subagents
client.Beta.Agents.Sessions.Subagents.List(ctx, sessionID, query) (*CursorPage[Subagent], error)
GET
/agents/sessions/{session_id}/subagents
Retrieve a session subagent
client.Beta.Agents.Sessions.Subagents.Get(ctx, sessionID, subagentID) (*Subagent, error)
GET
/agents/sessions/{session_id}/subagents/{subagent_id}

BetaAgentsSessionsSubagentsItems

List subagent items
client.Beta.Agents.Sessions.Subagents.Items.List(ctx, sessionID, subagentID, query) (*CursorPage[AgentSessionItemUnion], error)
GET
/agents/sessions/{session_id}/subagents/{subagent_id}/items

BetaAgentsSessionsSubagentsTurns

List subagent turns
client.Beta.Agents.Sessions.Subagents.Turns.List(ctx, sessionID, subagentID, query) (*CursorPage[Turn], error)
GET
/agents/sessions/{session_id}/subagents/{subagent_id}/turns
Retrieve a subagent turn
client.Beta.Agents.Sessions.Subagents.Turns.Get(ctx, sessionID, subagentID, turnID) (*Turn, error)
GET
/agents/sessions/{session_id}/subagents/{subagent_id}/turns/{turn_id}

BetaAgentsSessionsSubagentsTurnsItems

List subagent turn items
client.Beta.Agents.Sessions.Subagents.Turns.Items.List(ctx, sessionID, subagentID, turnID, query) (*CursorPage[AgentSessionItemUnion], error)
GET
/agents/sessions/{session_id}/subagents/{subagent_id}/turns/{turn_id}/items

BetaAgentsSessionsTraces

List agent session traces
client.Beta.Agents.Sessions.Traces.List(ctx, sessionID, query) (*CursorPage[SessionTrace], error)
GET
/agents/sessions/{session_id}/traces
Models
type SessionTrace struct{…}

BetaAgentsSessionsTurns

List agent session turns
client.Beta.Agents.Sessions.Turns.List(ctx, sessionID, query) (*CursorPage[Turn], error)
GET
/agents/sessions/{session_id}/turns
Retrieve an agent session turn
client.Beta.Agents.Sessions.Turns.Get(ctx, sessionID, turnID) (*Turn, error)
GET
/agents/sessions/{session_id}/turns/{turn_id}
Models
type Turn struct{…}

The canonical public representation of a session turn.

BetaAgentsSessionsTurnsItems

List agent session turn items
client.Beta.Agents.Sessions.Turns.Items.List(ctx, sessionID, turnID, query) (*ConversationCursorPage[AgentSessionItemUnion], error)
GET
/agents/sessions/{session_id}/turns/{turn_id}/items

BetaAgentsVaults

Create a vault
client.Beta.Agents.Vaults.New(ctx, body) (*Vault, error)
POST
/vaults
Delete a vault
client.Beta.Agents.Vaults.Delete(ctx, vaultID) (*VaultDeleted, error)
DELETE
/vaults/{vault_id}
List vaults
client.Beta.Agents.Vaults.List(ctx, query) (*CursorPage[Vault], error)
GET
/vaults
Retrieve a vault
client.Beta.Agents.Vaults.Get(ctx, vaultID) (*Vault, error)
GET
/vaults/{vault_id}
Update a vault
client.Beta.Agents.Vaults.Update(ctx, vaultID, body) (*Vault, error)
POST
/vaults/{vault_id}
Models
type Vault struct{…}

A collection of credentials for MCP servers and OpenAI-hosted environments.

type VaultDeleted struct{…}

Confirmation that a vault was deleted.

type VaultStatus string

Whether a vault or credential is active or archived.

type VaultStatusFilterUnion interface{…}

One or more lifecycle statuses to include when listing vaults or credentials.

BetaAgentsVaultsCredentials

Create a vault credential
client.Beta.Agents.Vaults.Credentials.New(ctx, vaultID, body) (*Credential, error)
POST
/vaults/{vault_id}/credentials
Delete a vault credential
client.Beta.Agents.Vaults.Credentials.Delete(ctx, vaultID, credentialID) (*CredentialDeleted, error)
DELETE
/vaults/{vault_id}/credentials/{credential_id}
List vault credentials
client.Beta.Agents.Vaults.Credentials.List(ctx, vaultID, query) (*CursorPage[Credential], error)
GET
/vaults/{vault_id}/credentials
Retrieve a vault credential
client.Beta.Agents.Vaults.Credentials.Get(ctx, vaultID, credentialID) (*Credential, error)
GET
/vaults/{vault_id}/credentials/{credential_id}
Update a vault credential
client.Beta.Agents.Vaults.Credentials.Update(ctx, vaultID, credentialID, body) (*Credential, error)
POST
/vaults/{vault_id}/credentials/{credential_id}
Models
type Credential struct{…}

Metadata for a stored credential. Secret values are never returned.

type CredentialAuthUnion interface{…}

The authentication configuration of a vault credential, excluding secrets.

type CredentialAuthCreateParamUnionResp interface{…}

Authentication credentials for an MCP server or an OpenAI-hosted environment.

type CredentialAuthRotateParamUnionResp interface{…}

Updates to a vault credential without changing its authentication method or destination configuration.

type CredentialDeleted struct{…}

Confirmation that a vault credential was deleted.

type CredentialNetworkingUnion interface{…}

Destination permissions for an environment-variable credential. These do not grant network access to the environment.

type CredentialNetworkingParamUnionResp interface{…}

Destination permissions for an environment-variable credential. These do not grant network access to the environment.

type McpOAuthTokenEndpointAuthUnion interface{…}

The client authentication method used for OAuth token refresh.

type McpOAuthTokenEndpointAuthCreateParamUnionResp interface{…}

Client authentication credentials for OAuth token refresh.

type McpOAuthTokenEndpointAuthRotateParamUnionResp interface{…}

Client-secret updates that preserve the credential’s OAuth authentication method.

BetaAssistants

Build Assistants that can call models and use tools.

Create assistant
Deprecated
client.Beta.Assistants.New(ctx, body) (*Assistant, error)
POST
/assistants
Delete assistant
Deprecated
client.Beta.Assistants.Delete(ctx, assistantID) (*AssistantDeleted, error)
DELETE
/assistants/{assistant_id}
List assistants
Deprecated
client.Beta.Assistants.List(ctx, query) (*CursorPage[Assistant], error)
GET
/assistants
Retrieve assistant
Deprecated
client.Beta.Assistants.Get(ctx, assistantID) (*Assistant, error)
GET
/assistants/{assistant_id}
Modify assistant
Deprecated
client.Beta.Assistants.Update(ctx, assistantID, body) (*Assistant, error)
POST
/assistants/{assistant_id}
Models
type Assistant struct{…}

Represents an assistant that can call the model and use tools.

type AssistantDeleted struct{…}
type AssistantStreamEventUnion interface{…}

Represents an event emitted when streaming a Run.

Each event in a server-sent events stream has an event and data property:

event: thread.created
data: {"id": "thread_123", "object": "thread", ...}

We emit events whenever a new object is created, transitions to a new state, or is being streamed in parts (deltas). For example, we emit thread.run.created when a new run is created, thread.run.completed when a run completes, and so on. When an Assistant chooses to create a message during a run, we emit a thread.message.created event, a thread.message.in_progress event, many thread.message.delta events, and finally a thread.message.completed event.

We may add additional events over time, so we recommend handling unknown events gracefully in your code. See the Assistants API quickstart to learn how to integrate the Assistants API with streaming.

type AssistantToolUnion interface{…}
type CodeInterpreterTool struct{…}
type FileSearchTool struct{…}
type FunctionTool struct{…}
type MessageStreamEventUnion interface{…}

Occurs when a message is created.

type RunStepStreamEventUnion interface{…}

Occurs when a run step is created.

type RunStreamEventUnion interface{…}

Occurs when a new run is created.

type ThreadStreamEvent struct{…}

Occurs when a new thread is created.

BetaChatKit

Models
type ChatKitWorkflow struct{…}

Workflow metadata and state returned for the session.

BetaChatKitSessions

Cancel a ChatKit session
client.Beta.ChatKit.Sessions.Cancel(ctx, sessionID) (*ChatSession, error)
POST
/chatkit/sessions/{session_id}/cancel
Create a ChatKit session
client.Beta.ChatKit.Sessions.New(ctx, body) (*ChatSession, error)
POST
/chatkit/sessions

BetaChatKitThreads

Delete a ChatKit thread
client.Beta.ChatKit.Threads.Delete(ctx, threadID) (*BetaChatKitThreadDeleteResponse, error)
DELETE
/chatkit/threads/{thread_id}
List ChatKit threads
client.Beta.ChatKit.Threads.List(ctx, query) (*ConversationCursorPage[ChatKitThread], error)
GET
/chatkit/threads
List ChatKit thread items
client.Beta.ChatKit.Threads.ListItems(ctx, threadID, query) (*ConversationCursorPage[ChatKitThreadItemListDataUnion], error)
GET
/chatkit/threads/{thread_id}/items
Retrieve a ChatKit thread
client.Beta.ChatKit.Threads.Get(ctx, threadID) (*ChatKitThread, error)
GET
/chatkit/threads/{thread_id}
Models
type ChatSession struct{…}

Represents a ChatKit session and its resolved configuration.

type ChatSessionAutomaticThreadTitling struct{…}

Automatic thread title preferences for the session.

type ChatSessionChatKitConfiguration struct{…}

ChatKit configuration for the session.

type ChatSessionChatKitConfigurationParamResp struct{…}

Optional per-session configuration settings for ChatKit behavior.

type ChatSessionExpiresAfterParamResp struct{…}

Controls when the session expires relative to an anchor timestamp.

type ChatSessionFileUpload struct{…}

Upload permissions and limits applied to the session.

type ChatSessionHistory struct{…}

History retention preferences returned for the session.

type ChatSessionRateLimits struct{…}

Active per-minute request limit for the session.

type ChatSessionRateLimitsParamResp struct{…}

Controls request rate limits for the session.

type ChatSessionStatus string
type ChatSessionWorkflowParamResp struct{…}

Workflow reference and overrides applied to the chat session.

type ChatKitAttachment struct{…}

Attachment metadata included on thread items.

type ChatKitResponseOutputText struct{…}

Assistant response text accompanied by optional annotations.

type ChatKitThread struct{…}

Represents a ChatKit thread and its current status.

type ChatKitThreadAssistantMessageItem struct{…}

Assistant-authored message within a thread.

type ChatKitThreadItemList struct{…}

A paginated list of thread items rendered for the ChatKit API.

type ChatKitThreadUserMessageItem struct{…}

User-authored messages within a thread.

type ChatKitWidgetItem struct{…}

Thread item that renders a widget payload.

BetaResponses

Create and manage model responses.

Cancel a response
client.Beta.Responses.Cancel(ctx, responseID, body) (*BetaResponse, error)
POST
/responses/{response_id}/cancel
Compact conversation
client.Beta.Responses.Compact(ctx, params) (*BetaCompactedResponse, error)
POST
/responses/compact
Create a model response
client.Beta.Responses.New(ctx, params) (*BetaResponse, error)
POST
/responses
Delete a model response
client.Beta.Responses.Delete(ctx, responseID, body) error
DELETE
/responses/{response_id}
Get a model response
client.Beta.Responses.Get(ctx, responseID, params) (*BetaResponse, error)
GET
/responses/{response_id}
Models
type BetaApplyPatchTool struct{…}

Allows the assistant to create, delete, or update files using unified diffs.

type BetaCompactedResponse struct{…}
type BetaComputerActionUnion interface{…}

A click action.

type BetaComputerActionList []BetaComputerActionUnion

Flattened batched actions for computer_use. Each action includes an type discriminator and action-specific fields.

type BetaComputerTool struct{…}

A tool that controls a virtual computer. Learn more about the computer tool.

type BetaComputerUsePreviewTool struct{…}

A tool that controls a virtual computer. Learn more about the computer tool.

type BetaContainerAuto struct{…}
type BetaContainerNetworkPolicyAllowlist struct{…}
type BetaContainerNetworkPolicyDisabled struct{…}
type BetaContainerNetworkPolicyDomainSecret struct{…}
type BetaContainerReference struct{…}
type BetaCustomTool struct{…}

A custom tool that processes input using a specified format. Learn more about custom tools

type BetaEasyInputMessage struct{…}

A message input to the model with a role indicating instruction following hierarchy. Instructions given with the developer or system role take precedence over instructions given with the user role. Messages with the assistant role are presumed to have been generated by the model in previous interactions.

type BetaFileSearchTool struct{…}

A tool that searches for relevant content from uploaded files. Learn more about the file search tool.

type BetaFileSearchToolFiltersCompoundFilter struct{…}

Combine multiple filters using and or or.

type BetaFunctionShellTool struct{…}

A tool that allows the model to execute shell commands.

type BetaFunctionTool struct{…}

Defines a function in your own code the model can choose to call. Learn more about function calling.

type BetaInlineSkill struct{…}
type BetaInlineSkillSource struct{…}

Inline skill payload

type BetaLocalEnvironment struct{…}
type BetaLocalSkill struct{…}
type BetaMcpToolCallErrorUnion interface{…}
type BetaNamespaceTool struct{…}

Groups function/custom tools under a shared namespace.

type BetaRecursiveCompoundFilter struct{…}

Combine multiple filters using and or or.

type BetaResponse struct{…}
type BetaResponseApplyPatchToolCall struct{…}

A tool call that applies file diffs by creating, deleting, or updating files.

type BetaResponseApplyPatchToolCallOutput struct{…}

The output emitted by an apply patch tool call.

type BetaResponseAudioDeltaEvent struct{…}

Emitted when there is a partial audio response.

type BetaResponseAudioDoneEvent struct{…}

Emitted when the audio response is complete.

type BetaResponseAudioTranscriptDeltaEvent struct{…}

Emitted when there is a partial transcript of audio.

type BetaResponseAudioTranscriptDoneEvent struct{…}

Emitted when the full audio transcript is completed.

type BetaResponseCodeInterpreterCallCodeDeltaEvent struct{…}

Emitted when a partial code snippet is streamed by the code interpreter.

type BetaResponseCodeInterpreterCallCodeDoneEvent struct{…}

Emitted when the code snippet is finalized by the code interpreter.

type BetaResponseCodeInterpreterCallCompletedEvent struct{…}

Emitted when the code interpreter call is completed.

type BetaResponseCodeInterpreterCallInProgressEvent struct{…}

Emitted when a code interpreter call is in progress.

type BetaResponseCodeInterpreterCallInterpretingEvent struct{…}

Emitted when the code interpreter is actively interpreting the code snippet.

type BetaResponseCodeInterpreterToolCall struct{…}

A tool call to run code.

type BetaResponseCompactionCompactingEvent struct{…}

Emitted when new summary content is sampled for a compaction trigger. Contains no summary content.

type BetaResponseCompactionItem struct{…}

A compaction item generated by the v1/responses/compact API.

type BetaResponseCompactionItemParamResp struct{…}

A compaction item generated by the v1/responses/compact API.

type BetaResponseCompletedEvent struct{…}

Emitted when the model response is complete.

type BetaResponseComputerToolCall struct{…}

A tool call to a computer use tool. See the computer use guide for more information.

type BetaResponseComputerToolCallOutputItem struct{…}
type BetaResponseComputerToolCallOutputScreenshot struct{…}

A computer screenshot image used with the computer use tool.

type BetaResponseConfigurationUpdateItem struct{…}

A configuration update that applies to subsequent responses until it is replaced by another configuration update.

type BetaResponseConfigurationUpdateItemParamResp struct{…}

An update to the conversation’s response configuration. The configuration remains in effect for subsequent responses until it is replaced by another configuration update.

type BetaResponseContainerReference struct{…}

Represents a container created with /v1/containers.

type BetaResponseContentUnion interface{…}

Multi-modal input and output contents.

type BetaResponseContentPartAddedEvent struct{…}

Emitted when a new content part is added.

type BetaResponseContentPartDoneEvent struct{…}

Emitted when a content part is done.

type BetaResponseConversationParamResp struct{…}

The conversation that this response belongs to.

type BetaResponseCreatedEvent struct{…}

An event that is emitted when a response is created.

type BetaResponseCustomToolCall struct{…}

A call to a custom tool created by the model.

type BetaResponseCustomToolCallInputDeltaEvent struct{…}

Event representing a delta (partial update) to the input of a custom tool call.

type BetaResponseCustomToolCallInputDoneEvent struct{…}

Event indicating that input for a custom tool call is complete.

type BetaResponseCustomToolCallItem struct{…}

A call to a custom tool created by the model.

type BetaResponseCustomToolCallOutput struct{…}

The output of a custom tool call from your code, being sent back to the model.

type BetaResponseCustomToolCallOutputItem struct{…}

The output of a custom tool call from your code, being sent back to the model.

type BetaResponseError struct{…}

An error object returned when the model fails to generate a Response.

type BetaResponseErrorEvent struct{…}

Emitted when an error occurs.

type BetaResponseFailedEvent struct{…}

An event that is emitted when a response fails.

type BetaResponseFileSearchCallCompletedEvent struct{…}

Emitted when a file search call is completed (results found).

type BetaResponseFileSearchCallInProgressEvent struct{…}

Emitted when a file search call is initiated.

type BetaResponseFileSearchCallSearchingEvent struct{…}

Emitted when a file search is currently searching.

type BetaResponseFileSearchToolCall struct{…}

The results of a file search tool call. See the file search guide for more information.

type BetaResponseFormatTextConfigUnion interface{…}

An object specifying the format that the model must output.

Configuring { "type": "json_schema" } enables Structured Outputs, which ensures the model will match your supplied JSON schema. Learn more in the Structured Outputs guide.

The default format is { "type": "text" } with no additional options.

Not recommended for gpt-4o and newer models:

Setting to { "type": "json_object" } enables the older JSON mode, which ensures the message the model generates is valid JSON. Using json_schema is preferred for models that support it.

type BetaResponseFormatTextJSONSchemaConfig struct{…}

JSON Schema response format. Used to generate structured JSON responses. Learn more about Structured Outputs.

type BetaResponseFunctionCallArgumentsDeltaEvent struct{…}

Emitted when there is a partial function-call arguments delta.

type BetaResponseFunctionCallArgumentsDoneEvent struct{…}

Emitted when function-call arguments are finalized.

type BetaResponseFunctionCallOutputItemUnion interface{…}

A piece of message content, such as text, an image, or a file.

type BetaResponseFunctionCallOutputItemList []BetaResponseFunctionCallOutputItemUnion

An array of content outputs (text, image, file) for the function tool call.

type BetaResponseFunctionShellCallOutputContent struct{…}

Captured stdout and stderr for a portion of a shell tool call output.

type BetaResponseFunctionShellToolCall struct{…}

A tool call that executes one or more shell commands in a managed environment.

type BetaResponseFunctionShellToolCallOutput struct{…}

The output of a shell tool call that was emitted.

type BetaResponseFunctionToolCall struct{…}

A tool call to run a function. See the function calling guide for more information.

type BetaResponseFunctionToolCallItem struct{…}

A tool call to run a function. See the function calling guide for more information.

type BetaResponseFunctionToolCallOutputItem struct{…}
type BetaResponseFunctionWebSearch struct{…}

The results of a web search tool call. See the web search guide for more information.

type BetaResponseImageGenCallCompletedEvent struct{…}

Emitted when an image generation tool call has completed and the final image is available.

type BetaResponseImageGenCallGeneratingEvent struct{…}

Emitted when an image generation tool call is actively generating an image (intermediate state).

type BetaResponseImageGenCallInProgressEvent struct{…}

Emitted when an image generation tool call is in progress.

type BetaResponseImageGenCallPartialImageEvent struct{…}

Emitted when a partial image is available during image generation streaming.

type BetaResponseInProgressEvent struct{…}

Emitted when the response is in progress.

type BetaResponseIncludable string

Specify additional output data to include in the model response. Currently supported values are:

  • web_search_call.results: Include the search results of the web search tool call.
  • web_search_call.action.sources: Include the sources of the web search tool call.
  • code_interpreter_call.outputs: Includes the outputs of python code execution in code interpreter tool call items.
  • computer_call_output.output.image_url: Include image urls from the computer call output.
  • file_search_call.results: Include the search results of the file search tool call.
  • message.input_image.image_url: Include image urls from the input message.
  • message.output_text.logprobs: Include logprobs with assistant messages.
  • reasoning.encrypted_content: Includes an encrypted version of reasoning tokens in reasoning item outputs. This enables reasoning items to be used in multi-turn conversations when using the Responses API statelessly (like when the store parameter is set to false, or when an organization is enrolled in the zero data retention program).
type BetaResponseIncompleteEvent struct{…}

An event that is emitted when a response finishes as incomplete.

Over WebSocket, steering can finish a response with response.incomplete_details.reason set to steered, followed automatically by a successor response.created that commits the queued steering input.

type BetaResponseInjectCreatedEvent struct{…}

Emitted when all injected input items were validated and committed to the active response.

type BetaResponseInjectEvent struct{…}

Injects input items into an active response over a WebSocket connection. The items are validated and committed atomically. Currently, the server accepts client-owned tool outputs that resume a waiting agent.

type BetaResponseInjectFailedEvent struct{…}

Emitted when injected input could not be committed to a response. The event returns the uncommitted raw input so the client can retry it in another response when appropriate.

type BetaResponseInput []BetaResponseInputItemUnion

A list of one or many input items to the model, containing different content types.

type BetaResponseInputAudio struct{…}

An audio input to the model.

type BetaResponseInputContentUnion interface{…}

A text input to the model.

type BetaResponseInputFile struct{…}

A file input to the model.

type BetaResponseInputFileContent struct{…}

A file input to the model.

type BetaResponseInputImage struct{…}

An image input to the model. Learn about image inputs.

type BetaResponseInputImageContent struct{…}

An image input to the model. Learn about image inputs

type BetaResponseInputItemUnion interface{…}

A message input to the model with a role indicating instruction following hierarchy. Instructions given with the developer or system role take precedence over instructions given with the user role. Messages with the assistant role are presumed to have been generated by the model in previous interactions.

type BetaResponseInputMessageContentList []BetaResponseInputContentUnion

A list of one or many input items to the model, containing different content types.

type BetaResponseInputMessageItem struct{…}
type BetaResponseInputText struct{…}

A text input to the model.

type BetaResponseInputTextContent struct{…}

A text input to the model.

type BetaResponseItemUnion interface{…}

Content item used to generate a response.

type BetaResponseLocalEnvironment struct{…}

Represents the use of a local environment to perform shell actions.

type BetaResponseMcpCallArgumentsDeltaEvent struct{…}

Emitted when there is a delta (partial update) to the arguments of an MCP tool call.

type BetaResponseMcpCallArgumentsDoneEvent struct{…}

Emitted when the arguments for an MCP tool call are finalized.

type BetaResponseMcpCallCompletedEvent struct{…}

Emitted when an MCP tool call has completed successfully.

type BetaResponseMcpCallFailedEvent struct{…}

Emitted when an MCP tool call has failed.

type BetaResponseMcpCallInProgressEvent struct{…}

Emitted when an MCP tool call is in progress.

type BetaResponseMcpListToolsCompletedEvent struct{…}

Emitted when the list of available MCP tools has been successfully retrieved.

type BetaResponseMcpListToolsFailedEvent struct{…}

Emitted when the attempt to list available MCP tools has failed.

type BetaResponseMcpListToolsInProgressEvent struct{…}

Emitted when the system is in the process of retrieving the list of available MCP tools.

type BetaResponseOutputAudio struct{…}

An audio output from the model.

type BetaResponseOutputItemUnion interface{…}

An output message from the model.

type BetaResponseOutputItemAddedEvent struct{…}

Emitted when a new output item is added.

type BetaResponseOutputItemDoneEvent struct{…}

Emitted when an output item is marked done.

type BetaResponseOutputMessage struct{…}

An output message from the model.

type BetaResponseOutputRefusal struct{…}

A refusal from the model.

type BetaResponseOutputText struct{…}

A text output from the model.

type BetaResponseOutputTextAnnotationAddedEvent struct{…}

Emitted when an annotation is added to output text content.

type BetaResponsePrompt struct{…}

Reference to a prompt template and its variables. Learn more.

type BetaResponseQueuedEvent struct{…}

Emitted when a response is queued and waiting to be processed.

type BetaResponseReasoningItem struct{…}

A description of the chain of thought used by a reasoning model while generating a response. Be sure to include these items in your input to the Responses API for subsequent turns of a conversation if you are manually managing context.

type BetaResponseReasoningSummaryPartAddedEvent struct{…}

Emitted when a new reasoning summary part is added.

type BetaResponseReasoningSummaryPartDoneEvent struct{…}

Emitted when a reasoning summary part is completed.

type BetaResponseReasoningSummaryTextDeltaEvent struct{…}

Emitted when a delta is added to a reasoning summary text.

type BetaResponseReasoningSummaryTextDoneEvent struct{…}

Emitted when a reasoning summary text is completed.

type BetaResponseReasoningTextDeltaEvent struct{…}

Emitted when a delta is added to a reasoning text.

type BetaResponseReasoningTextDoneEvent struct{…}

Emitted when a reasoning text is completed.

type BetaResponseRefusalDeltaEvent struct{…}

Emitted when there is a partial refusal text.

type BetaResponseRefusalDoneEvent struct{…}

Emitted when refusal text is finalized.

type BetaResponseShellCallCommandAddedEvent struct{…}

A streaming event that indicated a shell command was added to a tool call.

type BetaResponseShellCallCommandDeltaEvent struct{…}

A streaming event that indicated a shell command was incrementally updated.

type BetaResponseShellCallCommandDoneEvent struct{…}

A streaming event that indicated a shell command was completed.

type BetaResponseShellCallOutputContentDeltaEvent struct{…}

A streaming event that indicated shell call output was incrementally added.

type BetaResponseShellCallOutputContentDoneEvent struct{…}

A streaming event that indicated shell call output was completed.

type BetaResponseStatus string

The status of the response generation. One of completed, failed, in_progress, cancelled, queued, or incomplete.

type BetaResponseSteerAcceptedEvent struct{…}

Emitted when steering input has been validated and queued. Acceptance means the server owns the input, not that it has been applied. The successor’s response.created event is the commit point. If accepted input cannot be committed, response.steer.failed returns it with the same steering ID.

When the response stops for client-owned tool output or approval, the input remains queued and response.steer.pending is emitted after response.completed. Fill the pending event’s required_input stubs with saved results and send one matching explicit response.create per parent. Do not resend accepted input while it is still queued.

type BetaResponseSteerErrorCode interface{…}

A machine-readable steering error code. Clients should handle unknown values because additional codes may be introduced. Known values include:

  • response_not_found: The target response is not available on this connection.
  • invalid_input: The event or input failed validation.
  • steering_not_supported: The model or response execution mode does not support steering.
  • too_many_pending_steers: Too much steering input is pending for the response.
  • response_already_completed: The response completed and is no longer accepting steering input.
  • response_not_active: The response is no longer accepting steering input.
  • successor_creation_failed: The successor response could not be created.
type BetaResponseSteerEvent struct{…}

Queues user input to steer a response on this WebSocket connection. Input can contain text, images, and files. Steering is supported only for single-agent responses on models and execution modes that support steering. Responses bound to a conversation or using automatic compaction do not support steering.

A response.steer.accepted event acknowledges that the server owns the queued input, not that it has been applied. The successor’s response.created event is the commit point. Input that cannot be committed is returned in response.steer.failed.

Steering may cause the active response to finish at a safe output boundary with response.incomplete and incomplete_details.reason set to steered, followed automatically by a successor response.created. Normal completion can also be followed by an automatic successor. Automatic successors inherit the previous response’s settings and continue from it with the queued input.

If the response stops for client-owned tool output or approval, accepted steering input remains queued and response.steer.pending is emitted after response.completed. Fill the required_input stubs from that event with saved tool results or approval decisions, and send one explicit response.create per parent with the same previous_response_id and WebSocket lane. Do not rerun tools or resend accepted steering input. The queued input is prepended in submission order to that request’s input, and the explicit request retains its own settings.

This event accepts only type, previous_response_id, and input. Do not send stream_id; the target response determines the WebSocket lane.

type BetaResponseSteerFailedEvent struct{…}

Emitted when steering input is rejected or cannot be committed to a successor response. Returns the original, uncommitted input so the client can carry it into response.create when appropriate. Invalid input must be corrected before retrying.

Failures after acceptance include the same steering ID. Failures before an ID is allocated omit steer.id. A lost connection or missing acknowledgement leaves the outcome unknown; it is not proof that the input was rejected.

type BetaResponseSteerInputUnion interface{…}

Input to queue for a continuation of the response. Uses the same string or input-item shape as response.create.input, with a non-empty array when supplying input items.

Steering accepts only messages with the user role. Each message may contain only type, role, and content, with content as a string or an array of input_text, input_image, and input_file parts. The optional type must be message. Other roles, tool outputs, and item types are not supported for steering.

type BetaResponseSteerInputContentUnion interface{…}

A piece of message content, such as text, an image, or a file.

type BetaResponseSteerPendingEvent struct{…}

Emitted when accepted steering input remains queued after the target response completes. The server still owns the input. Do not resend it. The successor’s response.created event is the commit point.

When reason is waiting_for_required_input, this event follows response.completed while the response waits for the tool results or approval decisions identified by required_input. Copy those stubs, fill their result fields using the ordinary response.create input schemas, and submit one continuation per parent with the same previous_response_id and WebSocket lane. Use saved results without rerunning tools. The queued steering input is prepended in submission order to the continuation’s input. That explicit request retains its own settings.

This notification is emitted at most once per steering submission. Multiple submissions for the same parent can report the same required inputs; they do not each require a separate continuation.

type BetaResponseSteerPendingReason interface{…}

An extensible enum describing why accepted steering input is still queued. Clients should handle unknown values because additional reasons may be introduced. Known values include:

  • waiting_for_required_input: The response is waiting for the tool results or approval decisions identified by required_input.
type BetaResponseSteerRequiredInputUnion interface{…}

An input stub identifying an outstanding client-owned tool result or approval decision. Copy the stub and fill the result fields using the corresponding response.create input schema. Use saved results without rerunning the tool. The server does not supply results, approval decisions, or safety acknowledgements in these stubs.

type BetaResponseStreamEventUnion interface{…}

Event emitted while a response is streamed.

type BetaResponseTextConfig struct{…}

Configuration options for a text response from the model. Can be plain text or structured JSON data. Learn more:

type BetaResponseTextDeltaEvent struct{…}

Emitted when there is an additional text delta.

type BetaResponseTextDoneEvent struct{…}

Emitted when text content is finalized.

type BetaResponseToolSearchCall struct{…}
type BetaResponseToolSearchOutputItem struct{…}
type BetaResponseToolSearchOutputItemParamResp struct{…}
type BetaResponseUsage struct{…}

Represents token usage details including input tokens, output tokens, a breakdown of output tokens, and the total tokens used.

type BetaResponseWebSearchCallCompletedEvent struct{…}

Emitted when a web search call is completed.

type BetaResponseWebSearchCallInProgressEvent struct{…}

Emitted when a web search call is initiated.

type BetaResponseWebSearchCallSearchingEvent struct{…}

Emitted when a web search call is executing.

type BetaResponsesClientEventUnion interface{…}

Client events accepted by the Responses WebSocket server.

type BetaResponsesServerEventUnion interface{…}

Server events emitted by the Responses WebSocket server.

type BetaSkillReference struct{…}
type BetaToolUnion interface{…}

A tool that can be used to generate a response.

type BetaToolChoiceAllowed struct{…}

Constrains the tools available to the model to a pre-defined set.

type BetaToolChoiceApplyPatch struct{…}

Forces the model to call the apply_patch tool when executing a tool call.

type BetaToolChoiceCustom struct{…}

Use this option to force the model to call a specific custom tool.

type BetaToolChoiceFunction struct{…}

Use this option to force the model to call a specific function.

type BetaToolChoiceMcp struct{…}

Use this option to force the model to call a specific tool on a remote MCP server.

type BetaToolChoiceOptions string

Controls which (if any) tool is called by the model.

none means the model will not call any tool and instead generates a message.

auto means the model can pick between generating a message or calling one or more tools.

required means the model must call one or more tools.

type BetaToolChoiceShell struct{…}

Forces the model to call the shell tool when a tool call is required.

type BetaToolChoiceTypes struct{…}

Indicates that the model should use a built-in tool to generate a response. Learn more about built-in tools.

type BetaToolSearchOutputNamespaceTool struct{…}

Groups function/custom tools under a shared namespace.

type BetaToolSearchTool struct{…}

Hosted or BYOT tool search configuration for deferred tools.

type BetaWebSearchPreviewTool struct{…}

This tool searches the web for relevant results to use in a response. Learn more about the web search tool.

type BetaWebSearchTool struct{…}

Search the Internet for sources related to the prompt. Learn more about the web search tool.

BetaResponsesInput Items

Create and manage model responses.

List input items
client.Beta.Responses.InputItems.List(ctx, responseID, params) (*CursorPage[BetaResponseItemUnion], error)
GET
/responses/{response_id}/input_items
Models
type BetaResponseItemList struct{…}

A list of Response items.

BetaResponsesInput Tokens

Create and manage model responses.

Get input token counts
client.Beta.Responses.InputTokens.Count(ctx, params) (*BetaResponseInputTokenCountResponse, error)
POST
/responses/input_tokens

BetaThreads

Build Assistants that can call models and use tools.

Create thread
Deprecated
client.Beta.Threads.New(ctx, body) (*Thread, error)
POST
/threads
Create thread and run
Deprecated
client.Beta.Threads.NewAndRun(ctx, body) (*Run, error)
POST
/threads/runs
Delete thread
Deprecated
client.Beta.Threads.Delete(ctx, threadID) (*ThreadDeleted, error)
DELETE
/threads/{thread_id}
Retrieve thread
Deprecated
client.Beta.Threads.Get(ctx, threadID) (*Thread, error)
GET
/threads/{thread_id}
Modify thread
Deprecated
client.Beta.Threads.Update(ctx, threadID, body) (*Thread, error)
POST
/threads/{thread_id}
Models
type AssistantResponseFormatOptionUnion interface{…}

Specifies the format that the model must output. Compatible with GPT-4o, GPT-4 Turbo, and all GPT-3.5 Turbo models since gpt-3.5-turbo-1106.

Setting to { "type": "json_schema", "json_schema": {...} } enables Structured Outputs which ensures the model will match your supplied JSON schema. Learn more in the Structured Outputs guide.

Setting to { "type": "json_object" } enables JSON mode, which ensures the message the model generates is valid JSON.

Important: when using JSON mode, you must also instruct the model to produce JSON yourself via a system or user message. Without this, the model may generate an unending stream of whitespace until the generation reaches the token limit, resulting in a long-running and seemingly “stuck” request. Also note that the message content may be partially cut off if finish_reason="length", which indicates the generation exceeded max_tokens or the conversation exceeded the max context length.

type AssistantToolChoice struct{…}

Specifies a tool the model should use. Use to force the model to call a specific tool.

type AssistantToolChoiceFunction struct{…}
type AssistantToolChoiceOptionUnion interface{…}

Controls which (if any) tool is called by the model. none means the model will not call any tools and instead generates a message. auto is the default value and means the model can pick between generating a message or calling one or more tools. required means the model must call one or more tools before responding to the user. Specifying a particular tool like {"type": "file_search"} or {"type": "function", "function": {"name": "my_function"}} forces the model to call that tool.

type Thread struct{…}

Represents a thread that contains messages.

type ThreadDeleted struct{…}

BetaThreadsMessages

Build Assistants that can call models and use tools.

Create message
Deprecated
client.Beta.Threads.Messages.New(ctx, threadID, body) (*Message, error)
POST
/threads/{thread_id}/messages
Delete message
Deprecated
client.Beta.Threads.Messages.Delete(ctx, threadID, messageID) (*MessageDeleted, error)
DELETE
/threads/{thread_id}/messages/{message_id}
List messages
Deprecated
client.Beta.Threads.Messages.List(ctx, threadID, query) (*CursorPage[Message], error)
GET
/threads/{thread_id}/messages
Retrieve message
Deprecated
client.Beta.Threads.Messages.Get(ctx, threadID, messageID) (*Message, error)
GET
/threads/{thread_id}/messages/{message_id}
Modify message
Deprecated
client.Beta.Threads.Messages.Update(ctx, threadID, messageID, body) (*Message, error)
POST
/threads/{thread_id}/messages/{message_id}
Models
type AnnotationUnion interface{…}

A citation within the message that points to a specific quote from a specific File associated with the assistant or the message. Generated when the assistant uses the “file_search” tool to search files.

type AnnotationDeltaUnion interface{…}

A citation within the message that points to a specific quote from a specific File associated with the assistant or the message. Generated when the assistant uses the “file_search” tool to search files.

type FileCitationAnnotation struct{…}

A citation within the message that points to a specific quote from a specific File associated with the assistant or the message. Generated when the assistant uses the “file_search” tool to search files.

type FileCitationDeltaAnnotation struct{…}

A citation within the message that points to a specific quote from a specific File associated with the assistant or the message. Generated when the assistant uses the “file_search” tool to search files.

type FilePathAnnotation struct{…}

A URL for the file that’s generated when the assistant used the code_interpreter tool to generate a file.

type FilePathDeltaAnnotation struct{…}

A URL for the file that’s generated when the assistant used the code_interpreter tool to generate a file.

type ImageFile struct{…}
type ImageFileContentBlock struct{…}

References an image File in the content of a message.

type ImageFileDelta struct{…}
type ImageFileDeltaBlock struct{…}

References an image File in the content of a message.

type ImageURL struct{…}
type ImageURLContentBlock struct{…}

References an image URL in the content of a message.

type ImageURLDelta struct{…}
type ImageURLDeltaBlock struct{…}

References an image URL in the content of a message.

type Message struct{…}

Represents a message within a thread.

type MessageContentUnion interface{…}

References an image File in the content of a message.

type MessageContentDeltaUnion interface{…}

References an image File in the content of a message.

type MessageContentPartParamUnionResp interface{…}

References an image File in the content of a message.

type MessageDeleted struct{…}
type MessageDelta struct{…}

The delta containing the fields that have changed on the Message.

type MessageDeltaEvent struct{…}

Represents a message delta i.e. any changed fields on a message during streaming.

type RefusalContentBlock struct{…}

The refusal content generated by the assistant.

type RefusalDeltaBlock struct{…}

The refusal content that is part of a message.

type Text struct{…}
type TextContentBlock struct{…}

The text content that is part of a message.

type TextContentBlockParam struct{…}

The text content that is part of a message.

type TextDelta struct{…}
type TextDeltaBlock struct{…}

The text content that is part of a message.

BetaThreadsRuns

Build Assistants that can call models and use tools.

Cancel a run
Deprecated
client.Beta.Threads.Runs.Cancel(ctx, threadID, runID) (*Run, error)
POST
/threads/{thread_id}/runs/{run_id}/cancel
Create run
Deprecated
client.Beta.Threads.Runs.New(ctx, threadID, params) (*Run, error)
POST
/threads/{thread_id}/runs
List runs
Deprecated
client.Beta.Threads.Runs.List(ctx, threadID, query) (*CursorPage[Run], error)
GET
/threads/{thread_id}/runs
Retrieve run
Deprecated
client.Beta.Threads.Runs.Get(ctx, threadID, runID) (*Run, error)
GET
/threads/{thread_id}/runs/{run_id}
Submit tool outputs to run
Deprecated
client.Beta.Threads.Runs.SubmitToolOutputs(ctx, threadID, runID, body) (*Run, error)
POST
/threads/{thread_id}/runs/{run_id}/submit_tool_outputs
Modify run
Deprecated
client.Beta.Threads.Runs.Update(ctx, threadID, runID, body) (*Run, error)
POST
/threads/{thread_id}/runs/{run_id}
Models
type RequiredActionFunctionToolCall struct{…}

Tool call objects

type Run struct{…}

Represents an execution run on a thread.

type RunStatus string

The status of the run, which can be either queued, in_progress, requires_action, cancelling, cancelled, failed, completed, incomplete, or expired.

BetaThreadsRunsSteps

Build Assistants that can call models and use tools.

List run steps
Deprecated
client.Beta.Threads.Runs.Steps.List(ctx, threadID, runID, query) (*CursorPage[RunStep], error)
GET
/threads/{thread_id}/runs/{run_id}/steps
Retrieve run step
Deprecated
client.Beta.Threads.Runs.Steps.Get(ctx, threadID, runID, stepID, query) (*RunStep, error)
GET
/threads/{thread_id}/runs/{run_id}/steps/{step_id}
Models
type CodeInterpreterLogs struct{…}

Text output from the Code Interpreter tool call as part of a run step.

type CodeInterpreterOutputImage struct{…}
type CodeInterpreterToolCall struct{…}

Details of the Code Interpreter tool call the run step was involved in.

type CodeInterpreterToolCallDelta struct{…}

Details of the Code Interpreter tool call the run step was involved in.

type FileSearchToolCall struct{…}
type FileSearchToolCallDelta struct{…}
type FunctionToolCall struct{…}
type FunctionToolCallDelta struct{…}
type MessageCreationStepDetails struct{…}

Details of the message creation by the run step.

type RunStep struct{…}

Represents a step in execution of a run.

type RunStepDelta struct{…}

The delta containing the fields that have changed on the run step.

type RunStepDeltaEvent struct{…}

Represents a run step delta i.e. any changed fields on a run step during streaming.

type RunStepDeltaMessageDelta struct{…}

Details of the message creation by the run step.

type RunStepInclude string
type ToolCallUnion interface{…}

Details of the Code Interpreter tool call the run step was involved in.

type ToolCallDeltaUnion interface{…}

Details of the Code Interpreter tool call the run step was involved in.

type ToolCallDeltaObject struct{…}

Details of the tool call.

type ToolCallsStepDetails struct{…}

Details of the tool call.