Client Reference API

ACP Objects

`ApiClientConfiguration`

This class contains various settings of the API client.

Parameters:

host – Base url.
api_key – Dict to store API key(s). Each entry in the dict specifies an API key. The dict key is the name of the security scheme in the OAS specification. The dict value is the API key secret.
api_key_prefix – Dict to store API prefix (e.g. Bearer). The dict key is the name of the security scheme in the OAS specification. The dict value is an API key prefix when generating the auth data.
username – Username for HTTP basic authentication.
password – Password for HTTP basic authentication.
access_token – Access token.
server_variables – Mapping with string values to replace variables in templated server configuration. The validation of enums is performed for variables with defined enum values before.
server_operation_variables – Mapping from operation ID to a mapping with string values to replace variables in templated server configuration. The validation of enums is performed for variables with defined enum values before.
ssl_ca_cert – str - the path to a file of concatenated CA certificates in PEM format.
retries – Number of retries for API requests.
ca_cert_data – verify the peer using concatenated CA certificate data in PEM (str) or DER (bytes) format.
debug – Debug switch.

access_token: Access token

assert_hostname: Set this to True/False to enable/disable SSL hostname verification.

auth_settings() → AuthSettings

Gets Auth Settings dict for api client.

Returns:: The Auth Settings information dict.

ca_cert_data: Set this to verify the peer using PEM (str) or DER (bytes) certificate data.

cert_file: client certificate file

connection_pool_maxsize: urllib3 connection pool’s maximum number of connections saved per pool. urllib3 uses 1 connection as default value, but this is not the best value when you are making a lot of possibly parallel requests to the same host, which is often the case here. cpu_count * 5 is used as default value to increase performance.

date_format: date format

datetime_format: datetime format

property debug: bool

Debug status

Parameters:: value – The debug status, True or False.
Type:: bool

Construct a configuration object using environment variables as default source of parameter values. For example, with env_var_prefix=”MY_”, the default host parameter value would be looked up in the “MY_HOST” environment variable if not provided.

Parameters:: env_var_prefix – String used as prefix for environment variable names.
Returns:: Configuration object
Return type:: ApiClientConfiguration

get_api_key_with_prefix(identifier: str, alias: str | None = None) → str | None

Gets API key (with prefix if set).

Parameters:

identifier – The identifier of apiKey.
alias – The alternative identifier of apiKey.

Returns:

The token for api key authentication.

get_basic_auth_token() → str | None

Gets HTTP basic authentication header (string).

Returns:: The token for basic HTTP authentication.

classmethod get_default() → Self

Return the default configuration.

This method returns newly created, based on default constructor, object of Configuration class or returns a copy of default configuration.

Returns:: The configuration object.

classmethod get_default_copy() → Self

Deprecated. Please use get_default instead.

Returns:: The configuration object.

get_host_from_settings(index: int | None, variables: Dict[str, str] | None = None, servers: List[HostSetting] | None = None) → str: Gets host URL based on the index and variables :param index: array index of the host settings :param variables: hash of variable and the corresponding value :param servers: an array of host settings or None :return: URL based on host settings

get_host_settings() → List[HostSetting]

Gets an array of host settings

Returns:: An array of host settings

property host: str: Return generated host.

ignore_operation_servers: Ignore operation servers

key_file: client key file

logger: Logging Settings

property logger_file: str | None

The logger file.

If the logger_file is None, then add stream handler and remove file handler. Otherwise, add file handler and remove stream handler.

Parameters:: value – The logger_file path.
Type:: str

logger_file_handler: FileHandler | None: Log file handler

property logger_format: str

The logger format.

The logger_formatter will be updated when sets logger_format.

Parameters:: value – The format string.
Type:: str

logger_stream_handler: Log stream handler

password: Password for HTTP basic authentication

proxy: str | None: Proxy URL

proxy_headers: Proxy headers

refresh_api_key_hook: function hook to refresh API key if expired

retries: Adding retries to override urllib3 default value 3

safe_chars_for_path_param: Safe chars for path_param

server_operation_index: Default server index

server_operation_variables: Default server variables

classmethod set_default(default: Self | None) → None

Set default instance of configuration.

It stores default configuration, which can be returned by get_default_copy method.

Parameters:: default – object of Configuration

socket_options: Options to pass down to the underlying urllib3 socket

ssl_ca_cert: Set this to customize the certificate file to verify the peer.

temp_folder_path: Temp file folder for downloading files

tls_server_name: SSL/TLS Server Name Indication (SNI) Set this to the SNI value expected by the server.

to_debug_report() → str

Gets the essential information for debugging.

Returns:: The report for debugging.

username: Username for HTTP basic authentication

verify_ssl: SSL/TLS verification Set this to false to skip verifying SSL certificate when calling API from https server.

`ACPClient`

class agntcy_acp.ACPClient(api_client: ApiClient | None = None)

Client for ACP API.

cancel_stateless_run(run_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the run.')], wait: Annotated[bool, Strict(strict=True)] | None = None, action: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Action to take when cancelling the run. Possible values are `interrupt` or `rollback`. `interrupt` will simply cancel the run. `rollback` will cancel the run and delete the run and associated checkpoints afterwards.')] = None, _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → None

Cancel Stateless Run

Parameters:

run_id (str) – The ID of the run. (required)
wait (bool)
action (str) – Action to take when cancelling the run. Possible values are interrupt or rollback. interrupt will simply cancel the run. rollback will cancel the run and delete the run and associated checkpoints afterwards.
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

cancel_stateless_run_with_http_info(run_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the run.')], wait: Annotated[bool, Strict(strict=True)] | None = None, action: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Action to take when cancelling the run. Possible values are `interrupt` or `rollback`. `interrupt` will simply cancel the run. `rollback` will cancel the run and delete the run and associated checkpoints afterwards.')] = None, _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → ApiResponse[NoneType]

Cancel Stateless Run

Parameters:

run_id (str) – The ID of the run. (required)
wait (bool)
action (str) – Action to take when cancelling the run. Possible values are interrupt or rollback. interrupt will simply cancel the run. rollback will cancel the run and delete the run and associated checkpoints afterwards.
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

cancel_stateless_run_without_preload_content(run_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the run.')], wait: Annotated[bool, Strict(strict=True)] | None = None, action: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Action to take when cancelling the run. Possible values are `interrupt` or `rollback`. `interrupt` will simply cancel the run. `rollback` will cancel the run and delete the run and associated checkpoints afterwards.')] = None, _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → HTTPResponse

Cancel Stateless Run

Parameters:

run_id (str) – The ID of the run. (required)
wait (bool)
action (str) – Action to take when cancelling the run. Possible values are interrupt or rollback. interrupt will simply cancel the run. rollback will cancel the run and delete the run and associated checkpoints afterwards.
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

cancel_thread_run(thread_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the thread.')], run_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the run.')], wait: Annotated[bool, Strict(strict=True)] | None = None, action: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Action to take when cancelling the run. Possible values are `interrupt` or `rollback`. `interrupt` will simply cancel the run. `rollback` will cancel the run and delete the run and associated checkpoints afterwards.')] = None, _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → None

Cancel Run

Parameters:

thread_id (str) – The ID of the thread. (required)
run_id (str) – The ID of the run. (required)
wait (bool)
action (str) – Action to take when cancelling the run. Possible values are interrupt or rollback. interrupt will simply cancel the run. rollback will cancel the run and delete the run and associated checkpoints afterwards.
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

cancel_thread_run_with_http_info(thread_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the thread.')], run_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the run.')], wait: Annotated[bool, Strict(strict=True)] | None = None, action: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Action to take when cancelling the run. Possible values are `interrupt` or `rollback`. `interrupt` will simply cancel the run. `rollback` will cancel the run and delete the run and associated checkpoints afterwards.')] = None, _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → ApiResponse[NoneType]

Cancel Run

Parameters:

thread_id (str) – The ID of the thread. (required)
run_id (str) – The ID of the run. (required)
wait (bool)
action (str) – Action to take when cancelling the run. Possible values are interrupt or rollback. interrupt will simply cancel the run. rollback will cancel the run and delete the run and associated checkpoints afterwards.
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

cancel_thread_run_without_preload_content(thread_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the thread.')], run_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the run.')], wait: Annotated[bool, Strict(strict=True)] | None = None, action: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Action to take when cancelling the run. Possible values are `interrupt` or `rollback`. `interrupt` will simply cancel the run. `rollback` will cancel the run and delete the run and associated checkpoints afterwards.')] = None, _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → HTTPResponse

Cancel Run

Parameters:

thread_id (str) – The ID of the thread. (required)
run_id (str) – The ID of the run. (required)
wait (bool)
action (str) – Action to take when cancelling the run. Possible values are interrupt or rollback. interrupt will simply cancel the run. rollback will cancel the run and delete the run and associated checkpoints afterwards.
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

copy_thread(thread_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the thread.')], _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → Thread

Copy Thread

Create a new thread with a copy of the state and checkpoints from an existing thread.

Parameters:

thread_id (str) – The ID of the thread. (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

copy_thread_with_http_info(thread_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the thread.')], _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → ApiResponse[Thread]

Copy Thread

Create a new thread with a copy of the state and checkpoints from an existing thread.

Parameters:

thread_id (str) – The ID of the thread. (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

copy_thread_without_preload_content(thread_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the thread.')], _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → HTTPResponse

Copy Thread

Create a new thread with a copy of the state and checkpoints from an existing thread.

Parameters:

thread_id (str) – The ID of the thread. (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

create_and_stream_stateless_run_output(run_create_stateless: RunCreateStateless, _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → RunOutputStream

Create a stateless run and stream its output

Create a stateless run and join its output stream. See ‘GET /runs/{run_id}/stream’ for details on the return values.

Parameters:

run_create_stateless (RunCreateStateless) – (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

create_and_stream_stateless_run_output_with_http_info(run_create_stateless: RunCreateStateless, _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → ApiResponse[RunOutputStream]

Create a stateless run and stream its output

Create a stateless run and join its output stream. See ‘GET /runs/{run_id}/stream’ for details on the return values.

Parameters:

run_create_stateless (RunCreateStateless) – (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

create_and_stream_stateless_run_output_without_preload_content(run_create_stateless: RunCreateStateless, _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → HTTPResponse

Create a stateless run and stream its output

Create a stateless run and join its output stream. See ‘GET /runs/{run_id}/stream’ for details on the return values.

Parameters:

run_create_stateless (RunCreateStateless) – (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

create_and_stream_thread_run_output(thread_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the thread.')], run_create_stateful: RunCreateStateful, _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → RunOutputStream

Create a run on a thread and stream its output

Create a run on a thread and join its output stream. See ‘GET /runs/{run_id}/stream’ for details on the return values.

Parameters:

thread_id (str) – The ID of the thread. (required)
run_create_stateful (RunCreateStateful) – (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

create_and_stream_thread_run_output_with_http_info(thread_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the thread.')], run_create_stateful: RunCreateStateful, _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → ApiResponse[RunOutputStream]

Create a run on a thread and stream its output

Create a run on a thread and join its output stream. See ‘GET /runs/{run_id}/stream’ for details on the return values.

Parameters:

thread_id (str) – The ID of the thread. (required)
run_create_stateful (RunCreateStateful) – (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

create_and_stream_thread_run_output_without_preload_content(thread_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the thread.')], run_create_stateful: RunCreateStateful, _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → HTTPResponse

Create a run on a thread and stream its output

Create a run on a thread and join its output stream. See ‘GET /runs/{run_id}/stream’ for details on the return values.

Parameters:

thread_id (str) – The ID of the thread. (required)
run_create_stateful (RunCreateStateful) – (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

create_and_wait_for_stateless_run_output(run_create_stateless: RunCreateStateless, _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → RunWaitResponseStateless

Create a stateless run and wait for its output

Create a stateless run and wait for its output. See ‘GET /runs/{run_id}/wait’ for details on the return values.

Parameters:

run_create_stateless (RunCreateStateless) – (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

create_and_wait_for_stateless_run_output_with_http_info(run_create_stateless: RunCreateStateless, _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → ApiResponse[RunWaitResponseStateless]

Create a stateless run and wait for its output

Create a stateless run and wait for its output. See ‘GET /runs/{run_id}/wait’ for details on the return values.

Parameters:

run_create_stateless (RunCreateStateless) – (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

create_and_wait_for_stateless_run_output_without_preload_content(run_create_stateless: RunCreateStateless, _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → HTTPResponse

Create a stateless run and wait for its output

Create a stateless run and wait for its output. See ‘GET /runs/{run_id}/wait’ for details on the return values.

Parameters:

run_create_stateless (RunCreateStateless) – (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

create_and_wait_for_thread_run_output(thread_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the thread.')], run_create_stateful: RunCreateStateful, _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → RunWaitResponseStateful

Create a run on a thread and block waiting for the result of the run

Create a run on a thread and block waiting for its output. See ‘GET /runs/{run_id}/wait’ for details on the return values.

Parameters:

thread_id (str) – The ID of the thread. (required)
run_create_stateful (RunCreateStateful) – (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

create_and_wait_for_thread_run_output_with_http_info(thread_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the thread.')], run_create_stateful: RunCreateStateful, _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → ApiResponse[RunWaitResponseStateful]

Create a run on a thread and block waiting for the result of the run

Create a run on a thread and block waiting for its output. See ‘GET /runs/{run_id}/wait’ for details on the return values.

Parameters:

thread_id (str) – The ID of the thread. (required)
run_create_stateful (RunCreateStateful) – (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

create_and_wait_for_thread_run_output_without_preload_content(thread_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the thread.')], run_create_stateful: RunCreateStateful, _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → HTTPResponse

Create a run on a thread and block waiting for the result of the run

Create a run on a thread and block waiting for its output. See ‘GET /runs/{run_id}/wait’ for details on the return values.

Parameters:

thread_id (str) – The ID of the thread. (required)
run_create_stateful (RunCreateStateful) – (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

create_stateless_run(run_create_stateless: RunCreateStateless, _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → RunStateless

Create a Background stateless Run

Create a stateless run, return the run ID immediately. Don’t wait for the final run output.

Parameters:

run_create_stateless (RunCreateStateless) – (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

create_stateless_run_with_http_info(run_create_stateless: RunCreateStateless, _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → ApiResponse[RunStateless]

Create a Background stateless Run

Create a stateless run, return the run ID immediately. Don’t wait for the final run output.

Parameters:

run_create_stateless (RunCreateStateless) – (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

create_stateless_run_without_preload_content(run_create_stateless: RunCreateStateless, _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → HTTPResponse

Create a Background stateless Run

Create a stateless run, return the run ID immediately. Don’t wait for the final run output.

Parameters:

run_create_stateless (RunCreateStateless) – (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

create_thread(thread_create: ThreadCreate, _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → Thread

Create an empty Thread

Create a new thread.

Parameters:

thread_create (ThreadCreate) – (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

create_thread_run(thread_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the thread.')], run_create_stateful: RunCreateStateful, _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → RunStateful

Create a Background Run on a thread

Create a run on a thread, return the run ID immediately. Don’t wait for the final run output.

Parameters:

thread_id (str) – The ID of the thread. (required)
run_create_stateful (RunCreateStateful) – (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

create_thread_run_with_http_info(thread_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the thread.')], run_create_stateful: RunCreateStateful, _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → ApiResponse[RunStateful]

Create a Background Run on a thread

Create a run on a thread, return the run ID immediately. Don’t wait for the final run output.

Parameters:

thread_id (str) – The ID of the thread. (required)
run_create_stateful (RunCreateStateful) – (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

create_thread_run_without_preload_content(thread_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the thread.')], run_create_stateful: RunCreateStateful, _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → HTTPResponse

Create a Background Run on a thread

Create a run on a thread, return the run ID immediately. Don’t wait for the final run output.

Parameters:

thread_id (str) – The ID of the thread. (required)
run_create_stateful (RunCreateStateful) – (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

create_thread_with_http_info(thread_create: ThreadCreate, _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → ApiResponse[Thread]

Create an empty Thread

Create a new thread.

Parameters:

thread_create (ThreadCreate) – (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

create_thread_without_preload_content(thread_create: ThreadCreate, _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → HTTPResponse

Create an empty Thread

Create a new thread.

Parameters:

thread_create (ThreadCreate) – (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

delete_stateless_run(run_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the run.')], _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → None

Delete Stateless Run

Delete a stateless run by ID.

Parameters:

run_id (str) – The ID of the run. (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

delete_stateless_run_with_http_info(run_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the run.')], _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → ApiResponse[NoneType]

Delete Stateless Run

Delete a stateless run by ID.

Parameters:

run_id (str) – The ID of the run. (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

delete_stateless_run_without_preload_content(run_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the run.')], _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → HTTPResponse

Delete Stateless Run

Delete a stateless run by ID.

Parameters:

run_id (str) – The ID of the run. (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

delete_thread(thread_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the thread.')], _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → None

Delete a thread. If the thread contains any pending run, deletion fails.

Delete a thread.

Parameters:

thread_id (str) – The ID of the thread. (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

delete_thread_run(thread_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the thread.')], run_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the run.')], _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → None

Delete Run

Delete a run by ID.

Parameters:

thread_id (str) – The ID of the thread. (required)
run_id (str) – The ID of the run. (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

delete_thread_run_with_http_info(thread_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the thread.')], run_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the run.')], _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → ApiResponse[NoneType]

Delete Run

Delete a run by ID.

Parameters:

thread_id (str) – The ID of the thread. (required)
run_id (str) – The ID of the run. (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

delete_thread_run_without_preload_content(thread_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the thread.')], run_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the run.')], _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → HTTPResponse

Delete Run

Delete a run by ID.

Parameters:

thread_id (str) – The ID of the thread. (required)
run_id (str) – The ID of the run. (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

delete_thread_with_http_info(thread_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the thread.')], _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → ApiResponse[NoneType]

Delete a thread. If the thread contains any pending run, deletion fails.

Delete a thread.

Parameters:

thread_id (str) – The ID of the thread. (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

delete_thread_without_preload_content(thread_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the thread.')], _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → HTTPResponse

Delete a thread. If the thread contains any pending run, deletion fails.

Delete a thread.

Parameters:

thread_id (str) – The ID of the thread. (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

get_acp_descriptor_by_id(agent_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the agent.')], _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → AgentACPDescriptor

Get Agent ACP Descriptor from its id

Get agent ACP descriptor by agent ID.

Parameters:

agent_id (str) – The ID of the agent. (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

get_acp_descriptor_by_id_with_http_info(agent_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the agent.')], _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → ApiResponse[AgentACPDescriptor]

Get Agent ACP Descriptor from its id

Get agent ACP descriptor by agent ID.

Parameters:

agent_id (str) – The ID of the agent. (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

get_acp_descriptor_by_id_without_preload_content(agent_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the agent.')], _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → HTTPResponse

Get Agent ACP Descriptor from its id

Get agent ACP descriptor by agent ID.

Parameters:

agent_id (str) – The ID of the agent. (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

get_agent_by_id(agent_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the agent.')], _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → Agent

Get Agent

Get an agent by ID.

Parameters:

agent_id (str) – The ID of the agent. (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

get_agent_by_id_with_http_info(agent_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the agent.')], _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → ApiResponse[Agent]

Get Agent

Get an agent by ID.

Parameters:

agent_id (str) – The ID of the agent. (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

get_agent_by_id_without_preload_content(agent_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the agent.')], _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → HTTPResponse

Get Agent

Get an agent by ID.

Parameters:

agent_id (str) – The ID of the agent. (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

get_stateless_run(run_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the run.')], _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → RunStateless

Get Run

Get a stateless run by ID.

Parameters:

run_id (str) – The ID of the run. (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

get_stateless_run_with_http_info(run_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the run.')], _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → ApiResponse[RunStateless]

Get Run

Get a stateless run by ID.

Parameters:

run_id (str) – The ID of the run. (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

get_stateless_run_without_preload_content(run_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the run.')], _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → HTTPResponse

Get Run

Get a stateless run by ID.

Parameters:

run_id (str) – The ID of the run. (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

get_thread(thread_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the thread.')], _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → Thread

Get Thread

Get a thread from its ID.

Parameters:

thread_id (str) – The ID of the thread. (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

get_thread_history(thread_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the thread.')], limit: Annotated[int, Strict(strict=True)] | None = None, before: Annotated[str, Strict(strict=True)] | None = None, _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → List[ThreadState]

Get Thread History

Get all past states for a thread.

Parameters:

thread_id (str) – The ID of the thread. (required)
limit (int)
before (str)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

get_thread_history_with_http_info(thread_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the thread.')], limit: Annotated[int, Strict(strict=True)] | None = None, before: Annotated[str, Strict(strict=True)] | None = None, _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → ApiResponse[List[ThreadState]]

Get Thread History

Get all past states for a thread.

Parameters:

thread_id (str) – The ID of the thread. (required)
limit (int)
before (str)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

get_thread_history_without_preload_content(thread_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the thread.')], limit: Annotated[int, Strict(strict=True)] | None = None, before: Annotated[str, Strict(strict=True)] | None = None, _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → HTTPResponse

Get Thread History

Get all past states for a thread.

Parameters:

thread_id (str) – The ID of the thread. (required)
limit (int)
before (str)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

get_thread_run(thread_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the thread.')], run_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the run.')], _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → RunStateful

Get Run

Get a run by ID.

Parameters:

thread_id (str) – The ID of the thread. (required)
run_id (str) – The ID of the run. (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

get_thread_run_with_http_info(thread_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the thread.')], run_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the run.')], _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → ApiResponse[RunStateful]

Get Run

Get a run by ID.

Parameters:

thread_id (str) – The ID of the thread. (required)
run_id (str) – The ID of the run. (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

get_thread_run_without_preload_content(thread_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the thread.')], run_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the run.')], _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → HTTPResponse

Get Run

Get a run by ID.

Parameters:

thread_id (str) – The ID of the thread. (required)
run_id (str) – The ID of the run. (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

get_thread_with_http_info(thread_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the thread.')], _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → ApiResponse[Thread]

Get Thread

Get a thread from its ID.

Parameters:

thread_id (str) – The ID of the thread. (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

get_thread_without_preload_content(thread_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the thread.')], _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → HTTPResponse

Get Thread

Get a thread from its ID.

Parameters:

thread_id (str) – The ID of the thread. (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

list_thread_runs(thread_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the thread.')], limit: Annotated[int, Strict(strict=True)] | None = None, offset: Annotated[int, Strict(strict=True)] | None = None, _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → List[RunStateful]

List Runs for a thread

List runs for a thread.

Parameters:

thread_id (str) – The ID of the thread. (required)
limit (int)
offset (int)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

list_thread_runs_with_http_info(thread_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the thread.')], limit: Annotated[int, Strict(strict=True)] | None = None, offset: Annotated[int, Strict(strict=True)] | None = None, _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → ApiResponse[List[RunStateful]]

List Runs for a thread

List runs for a thread.

Parameters:

thread_id (str) – The ID of the thread. (required)
limit (int)
offset (int)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

list_thread_runs_without_preload_content(thread_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the thread.')], limit: Annotated[int, Strict(strict=True)] | None = None, offset: Annotated[int, Strict(strict=True)] | None = None, _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → HTTPResponse

List Runs for a thread

List runs for a thread.

Parameters:

thread_id (str) – The ID of the thread. (required)
limit (int)
offset (int)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

patch_thread(thread_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the thread.')], thread_patch: ThreadPatch, _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → Thread

Patch Thread

Update a thread.

Parameters:

thread_id (str) – The ID of the thread. (required)
thread_patch (ThreadPatch) – (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

patch_thread_with_http_info(thread_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the thread.')], thread_patch: ThreadPatch, _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → ApiResponse[Thread]

Patch Thread

Update a thread.

Parameters:

thread_id (str) – The ID of the thread. (required)
thread_patch (ThreadPatch) – (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

patch_thread_without_preload_content(thread_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the thread.')], thread_patch: ThreadPatch, _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → HTTPResponse

Patch Thread

Update a thread.

Parameters:

thread_id (str) – The ID of the thread. (required)
thread_patch (ThreadPatch) – (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

resume_stateless_run(run_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the run.')], body: Dict[str, Any], _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → RunStateless

Resume an interrupted Run

Provide the needed input to a run to resume its execution. Can only be called for runs that are in the interrupted state Schema of the provided input must match with the schema specified in the agent specs under interrupts for the interrupt type the agent generated for this specific interruption.

Parameters:

run_id (str) – The ID of the run. (required)
body (object) – (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

resume_stateless_run_with_http_info(run_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the run.')], body: Dict[str, Any], _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → ApiResponse[RunStateless]

Resume an interrupted Run

Provide the needed input to a run to resume its execution. Can only be called for runs that are in the interrupted state Schema of the provided input must match with the schema specified in the agent specs under interrupts for the interrupt type the agent generated for this specific interruption.

Parameters:

run_id (str) – The ID of the run. (required)
body (object) – (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

resume_stateless_run_without_preload_content(run_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the run.')], body: Dict[str, Any], _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → HTTPResponse

Resume an interrupted Run

Provide the needed input to a run to resume its execution. Can only be called for runs that are in the interrupted state Schema of the provided input must match with the schema specified in the agent specs under interrupts for the interrupt type the agent generated for this specific interruption.

Parameters:

run_id (str) – The ID of the run. (required)
body (object) – (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

resume_thread_run(thread_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the thread.')], run_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the run.')], body: Dict[str, Any], _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → RunStateful

Resume an interrupted Run

Provide the needed input to a run to resume its execution. Can only be called for runs that are in the interrupted state Schema of the provided input must match with the schema specified in the agent specs under interrupts for the interrupt type the agent generated for this specific interruption.

Parameters:

thread_id (str) – The ID of the thread. (required)
run_id (str) – The ID of the run. (required)
body (object) – (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

resume_thread_run_with_http_info(thread_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the thread.')], run_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the run.')], body: Dict[str, Any], _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → ApiResponse[RunStateful]

Resume an interrupted Run

Provide the needed input to a run to resume its execution. Can only be called for runs that are in the interrupted state Schema of the provided input must match with the schema specified in the agent specs under interrupts for the interrupt type the agent generated for this specific interruption.

Parameters:

thread_id (str) – The ID of the thread. (required)
run_id (str) – The ID of the run. (required)
body (object) – (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

resume_thread_run_without_preload_content(thread_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the thread.')], run_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the run.')], body: Dict[str, Any], _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → HTTPResponse

Resume an interrupted Run

Provide the needed input to a run to resume its execution. Can only be called for runs that are in the interrupted state Schema of the provided input must match with the schema specified in the agent specs under interrupts for the interrupt type the agent generated for this specific interruption.

Parameters:

thread_id (str) – The ID of the thread. (required)
run_id (str) – The ID of the run. (required)
body (object) – (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

search_agents(agent_search_request: AgentSearchRequest, _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → List[Agent]

Search Agents

Returns a list of agents matching the criteria provided in the request. This endpoint also functions as the endpoint to list all agents.

Parameters:

agent_search_request (AgentSearchRequest) – (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

search_agents_with_http_info(agent_search_request: AgentSearchRequest, _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → ApiResponse[List[Agent]]

Search Agents

Returns a list of agents matching the criteria provided in the request. This endpoint also functions as the endpoint to list all agents.

Parameters:

agent_search_request (AgentSearchRequest) – (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

search_agents_without_preload_content(agent_search_request: AgentSearchRequest, _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → HTTPResponse

Search Agents

Returns a list of agents matching the criteria provided in the request. This endpoint also functions as the endpoint to list all agents.

Parameters:

agent_search_request (AgentSearchRequest) – (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

search_stateless_runs(run_search_request: RunSearchRequest, _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → List[RunStateless]

Search Stateless Runs

Search for stateless run. This endpoint also functions as the endpoint to list all stateless Runs.

Parameters:

run_search_request (RunSearchRequest) – (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

search_stateless_runs_with_http_info(run_search_request: RunSearchRequest, _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → ApiResponse[List[RunStateless]]

Search Stateless Runs

Search for stateless run. This endpoint also functions as the endpoint to list all stateless Runs.

Parameters:

run_search_request (RunSearchRequest) – (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

search_stateless_runs_without_preload_content(run_search_request: RunSearchRequest, _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → HTTPResponse

Search Stateless Runs

Search for stateless run. This endpoint also functions as the endpoint to list all stateless Runs.

Parameters:

run_search_request (RunSearchRequest) – (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

search_threads(thread_search_request: ThreadSearchRequest, _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → List[Thread]

Search Threads

Search for threads. This endpoint also functions as the endpoint to list all threads.

Parameters:

thread_search_request (ThreadSearchRequest) – (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

search_threads_with_http_info(thread_search_request: ThreadSearchRequest, _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → ApiResponse[List[Thread]]

Search Threads

Search for threads. This endpoint also functions as the endpoint to list all threads.

Parameters:

thread_search_request (ThreadSearchRequest) – (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

search_threads_without_preload_content(thread_search_request: ThreadSearchRequest, _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → HTTPResponse

Search Threads

Search for threads. This endpoint also functions as the endpoint to list all threads.

Parameters:

thread_search_request (ThreadSearchRequest) – (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

stream_stateless_run_output(run_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the run.')], _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → RunOutputStream

Stream output from Stateless Run

Join the output stream of an existing run. This endpoint streams output in real-time from a run. Only output produced after this endpoint is called will be streamed.

Parameters:

run_id (str) – The ID of the run. (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

stream_stateless_run_output_with_http_info(run_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the run.')], _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → ApiResponse[RunOutputStream]

Stream output from Stateless Run

Join the output stream of an existing run. This endpoint streams output in real-time from a run. Only output produced after this endpoint is called will be streamed.

Parameters:

run_id (str) – The ID of the run. (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

stream_stateless_run_output_without_preload_content(run_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the run.')], _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → HTTPResponse

Stream output from Stateless Run

Join the output stream of an existing run. This endpoint streams output in real-time from a run. Only output produced after this endpoint is called will be streamed.

Parameters:

run_id (str) – The ID of the run. (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

stream_thread_run_output(thread_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the thread.')], run_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the run.')], _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → RunOutputStream

Stream output from Run

Join the output stream of an existing run. See ‘GET /runs/{run_id}/stream’ for details on the return values.

Parameters:

thread_id (str) – The ID of the thread. (required)
run_id (str) – The ID of the run. (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

stream_thread_run_output_with_http_info(thread_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the thread.')], run_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the run.')], _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → ApiResponse[RunOutputStream]

Stream output from Run

Join the output stream of an existing run. See ‘GET /runs/{run_id}/stream’ for details on the return values.

Parameters:

thread_id (str) – The ID of the thread. (required)
run_id (str) – The ID of the run. (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

stream_thread_run_output_without_preload_content(thread_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the thread.')], run_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the run.')], _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → HTTPResponse

Stream output from Run

Join the output stream of an existing run. See ‘GET /runs/{run_id}/stream’ for details on the return values.

Parameters:

thread_id (str) – The ID of the thread. (required)
run_id (str) – The ID of the run. (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

wait_for_stateless_run_output(run_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the run.')], _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → RunWaitResponseStateless

Blocks waiting for the result of the run.

Blocks waiting for the result of the run. The output can be: * an interrupt, this happens when the agent run status is interrupted * the final result of the run, this happens when the agent run status is success * an error, this happens when the agent run status is error or timeout This call blocks until the output is available.

Parameters:

run_id (str) – The ID of the run. (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

wait_for_stateless_run_output_with_http_info(run_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the run.')], _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → ApiResponse[RunWaitResponseStateless]

Blocks waiting for the result of the run.

Blocks waiting for the result of the run. The output can be: * an interrupt, this happens when the agent run status is interrupted * the final result of the run, this happens when the agent run status is success * an error, this happens when the agent run status is error or timeout This call blocks until the output is available.

Parameters:

run_id (str) – The ID of the run. (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

wait_for_stateless_run_output_without_preload_content(run_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the run.')], _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → HTTPResponse

Blocks waiting for the result of the run.

Blocks waiting for the result of the run. The output can be: * an interrupt, this happens when the agent run status is interrupted * the final result of the run, this happens when the agent run status is success * an error, this happens when the agent run status is error or timeout This call blocks until the output is available.

Parameters:

run_id (str) – The ID of the run. (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

wait_for_thread_run_output(thread_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the thread.')], run_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the run.')], _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → RunWaitResponseStateful

Blocks waiting for the result of the run.

Blocks waiting for the result of the run. See ‘GET /runs/{run_id}/wait’ for details on the return values.

Parameters:

thread_id (str) – The ID of the thread. (required)
run_id (str) – The ID of the run. (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

wait_for_thread_run_output_with_http_info(thread_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the thread.')], run_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the run.')], _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → ApiResponse[RunWaitResponseStateful]

Blocks waiting for the result of the run.

Blocks waiting for the result of the run. See ‘GET /runs/{run_id}/wait’ for details on the return values.

Parameters:

thread_id (str) – The ID of the thread. (required)
run_id (str) – The ID of the run. (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

wait_for_thread_run_output_without_preload_content(thread_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the thread.')], run_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the run.')], _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → HTTPResponse

Blocks waiting for the result of the run.

Blocks waiting for the result of the run. See ‘GET /runs/{run_id}/wait’ for details on the return values.

Parameters:

thread_id (str) – The ID of the thread. (required)
run_id (str) – The ID of the run. (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

`AsyncACPClient`

class agntcy_acp.AsyncACPClient(api_client: ApiClient | None = None)

Async client for ACP API.

async cancel_stateless_run(run_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the run.')], wait: Annotated[bool, Strict(strict=True)] | None = None, action: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Action to take when cancelling the run. Possible values are `interrupt` or `rollback`. `interrupt` will simply cancel the run. `rollback` will cancel the run and delete the run and associated checkpoints afterwards.')] = None, _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → None

Cancel Stateless Run

Parameters:

run_id (str) – The ID of the run. (required)
wait (bool)
action (str) – Action to take when cancelling the run. Possible values are interrupt or rollback. interrupt will simply cancel the run. rollback will cancel the run and delete the run and associated checkpoints afterwards.
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

async cancel_stateless_run_with_http_info(run_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the run.')], wait: Annotated[bool, Strict(strict=True)] | None = None, action: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Action to take when cancelling the run. Possible values are `interrupt` or `rollback`. `interrupt` will simply cancel the run. `rollback` will cancel the run and delete the run and associated checkpoints afterwards.')] = None, _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → ApiResponse[NoneType]

Cancel Stateless Run

Parameters:

run_id (str) – The ID of the run. (required)
wait (bool)
action (str) – Action to take when cancelling the run. Possible values are interrupt or rollback. interrupt will simply cancel the run. rollback will cancel the run and delete the run and associated checkpoints afterwards.
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

async cancel_stateless_run_without_preload_content(run_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the run.')], wait: Annotated[bool, Strict(strict=True)] | None = None, action: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Action to take when cancelling the run. Possible values are `interrupt` or `rollback`. `interrupt` will simply cancel the run. `rollback` will cancel the run and delete the run and associated checkpoints afterwards.')] = None, _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → ClientResponse

Cancel Stateless Run

Parameters:

run_id (str) – The ID of the run. (required)
wait (bool)
action (str) – Action to take when cancelling the run. Possible values are interrupt or rollback. interrupt will simply cancel the run. rollback will cancel the run and delete the run and associated checkpoints afterwards.
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

async cancel_thread_run(thread_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the thread.')], run_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the run.')], wait: Annotated[bool, Strict(strict=True)] | None = None, action: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Action to take when cancelling the run. Possible values are `interrupt` or `rollback`. `interrupt` will simply cancel the run. `rollback` will cancel the run and delete the run and associated checkpoints afterwards.')] = None, _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → None

Cancel Run

Parameters:

thread_id (str) – The ID of the thread. (required)
run_id (str) – The ID of the run. (required)
wait (bool)
action (str) – Action to take when cancelling the run. Possible values are interrupt or rollback. interrupt will simply cancel the run. rollback will cancel the run and delete the run and associated checkpoints afterwards.
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

async cancel_thread_run_with_http_info(thread_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the thread.')], run_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the run.')], wait: Annotated[bool, Strict(strict=True)] | None = None, action: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Action to take when cancelling the run. Possible values are `interrupt` or `rollback`. `interrupt` will simply cancel the run. `rollback` will cancel the run and delete the run and associated checkpoints afterwards.')] = None, _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → ApiResponse[NoneType]

Cancel Run

Parameters:

thread_id (str) – The ID of the thread. (required)
run_id (str) – The ID of the run. (required)
wait (bool)
action (str) – Action to take when cancelling the run. Possible values are interrupt or rollback. interrupt will simply cancel the run. rollback will cancel the run and delete the run and associated checkpoints afterwards.
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

async cancel_thread_run_without_preload_content(thread_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the thread.')], run_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the run.')], wait: Annotated[bool, Strict(strict=True)] | None = None, action: Annotated[Annotated[str, Strict(strict=True)] | None, FieldInfo(annotation=NoneType, required=True, description='Action to take when cancelling the run. Possible values are `interrupt` or `rollback`. `interrupt` will simply cancel the run. `rollback` will cancel the run and delete the run and associated checkpoints afterwards.')] = None, _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → ClientResponse

Cancel Run

Parameters:

thread_id (str) – The ID of the thread. (required)
run_id (str) – The ID of the run. (required)
wait (bool)
action (str) – Action to take when cancelling the run. Possible values are interrupt or rollback. interrupt will simply cancel the run. rollback will cancel the run and delete the run and associated checkpoints afterwards.
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

async copy_thread(thread_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the thread.')], _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → Thread

Copy Thread

Create a new thread with a copy of the state and checkpoints from an existing thread.

Parameters:

thread_id (str) – The ID of the thread. (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

async copy_thread_with_http_info(thread_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the thread.')], _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → ApiResponse[Thread]

Copy Thread

Create a new thread with a copy of the state and checkpoints from an existing thread.

Parameters:

thread_id (str) – The ID of the thread. (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

async copy_thread_without_preload_content(thread_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the thread.')], _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → ClientResponse

Copy Thread

Create a new thread with a copy of the state and checkpoints from an existing thread.

Parameters:

thread_id (str) – The ID of the thread. (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

async create_and_stream_stateless_run_output(run_create_stateless: RunCreateStateless, _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → RunOutputStream

Create a stateless run and stream its output

Create a stateless run and join its output stream. See ‘GET /runs/{run_id}/stream’ for details on the return values.

Parameters:

run_create_stateless (RunCreateStateless) – (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

async create_and_stream_stateless_run_output_with_http_info(run_create_stateless: RunCreateStateless, _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → ApiResponse[RunOutputStream]

Create a stateless run and stream its output

Create a stateless run and join its output stream. See ‘GET /runs/{run_id}/stream’ for details on the return values.

Parameters:

run_create_stateless (RunCreateStateless) – (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

async create_and_stream_stateless_run_output_without_preload_content(run_create_stateless: RunCreateStateless, _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → ClientResponse

Create a stateless run and stream its output

Create a stateless run and join its output stream. See ‘GET /runs/{run_id}/stream’ for details on the return values.

Parameters:

run_create_stateless (RunCreateStateless) – (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

async create_and_stream_thread_run_output(thread_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the thread.')], run_create_stateful: RunCreateStateful, _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → RunOutputStream

Create a run on a thread and stream its output

Create a run on a thread and join its output stream. See ‘GET /runs/{run_id}/stream’ for details on the return values.

Parameters:

thread_id (str) – The ID of the thread. (required)
run_create_stateful (RunCreateStateful) – (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

async create_and_stream_thread_run_output_with_http_info(thread_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the thread.')], run_create_stateful: RunCreateStateful, _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → ApiResponse[RunOutputStream]

Create a run on a thread and stream its output

Create a run on a thread and join its output stream. See ‘GET /runs/{run_id}/stream’ for details on the return values.

Parameters:

thread_id (str) – The ID of the thread. (required)
run_create_stateful (RunCreateStateful) – (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

async create_and_stream_thread_run_output_without_preload_content(thread_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the thread.')], run_create_stateful: RunCreateStateful, _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → ClientResponse

Create a run on a thread and stream its output

Create a run on a thread and join its output stream. See ‘GET /runs/{run_id}/stream’ for details on the return values.

Parameters:

thread_id (str) – The ID of the thread. (required)
run_create_stateful (RunCreateStateful) – (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

async create_and_wait_for_stateless_run_output(run_create_stateless: RunCreateStateless, _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → RunWaitResponseStateless

Create a stateless run and wait for its output

Create a stateless run and wait for its output. See ‘GET /runs/{run_id}/wait’ for details on the return values.

Parameters:

run_create_stateless (RunCreateStateless) – (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

async create_and_wait_for_stateless_run_output_with_http_info(run_create_stateless: RunCreateStateless, _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → ApiResponse[RunWaitResponseStateless]

Create a stateless run and wait for its output

Create a stateless run and wait for its output. See ‘GET /runs/{run_id}/wait’ for details on the return values.

Parameters:

run_create_stateless (RunCreateStateless) – (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

async create_and_wait_for_stateless_run_output_without_preload_content(run_create_stateless: RunCreateStateless, _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → ClientResponse

Create a stateless run and wait for its output

Create a stateless run and wait for its output. See ‘GET /runs/{run_id}/wait’ for details on the return values.

Parameters:

run_create_stateless (RunCreateStateless) – (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

async create_and_wait_for_thread_run_output(thread_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the thread.')], run_create_stateful: RunCreateStateful, _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → RunWaitResponseStateful

Create a run on a thread and block waiting for the result of the run

Create a run on a thread and block waiting for its output. See ‘GET /runs/{run_id}/wait’ for details on the return values.

Parameters:

thread_id (str) – The ID of the thread. (required)
run_create_stateful (RunCreateStateful) – (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

async create_and_wait_for_thread_run_output_with_http_info(thread_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the thread.')], run_create_stateful: RunCreateStateful, _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → ApiResponse[RunWaitResponseStateful]

Create a run on a thread and block waiting for the result of the run

Create a run on a thread and block waiting for its output. See ‘GET /runs/{run_id}/wait’ for details on the return values.

Parameters:

thread_id (str) – The ID of the thread. (required)
run_create_stateful (RunCreateStateful) – (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

async create_and_wait_for_thread_run_output_without_preload_content(thread_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the thread.')], run_create_stateful: RunCreateStateful, _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → ClientResponse

Create a run on a thread and block waiting for the result of the run

Create a run on a thread and block waiting for its output. See ‘GET /runs/{run_id}/wait’ for details on the return values.

Parameters:

thread_id (str) – The ID of the thread. (required)
run_create_stateful (RunCreateStateful) – (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

async create_stateless_run(run_create_stateless: RunCreateStateless, _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → RunStateless

Create a Background stateless Run

Create a stateless run, return the run ID immediately. Don’t wait for the final run output.

Parameters:

run_create_stateless (RunCreateStateless) – (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

async create_stateless_run_with_http_info(run_create_stateless: RunCreateStateless, _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → ApiResponse[RunStateless]

Create a Background stateless Run

Create a stateless run, return the run ID immediately. Don’t wait for the final run output.

Parameters:

run_create_stateless (RunCreateStateless) – (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

async create_stateless_run_without_preload_content(run_create_stateless: RunCreateStateless, _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → ClientResponse

Create a Background stateless Run

Create a stateless run, return the run ID immediately. Don’t wait for the final run output.

Parameters:

run_create_stateless (RunCreateStateless) – (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

async create_thread(thread_create: ThreadCreate, _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → Thread

Create an empty Thread

Create a new thread.

Parameters:

thread_create (ThreadCreate) – (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

async create_thread_run(thread_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the thread.')], run_create_stateful: RunCreateStateful, _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → RunStateful

Create a Background Run on a thread

Create a run on a thread, return the run ID immediately. Don’t wait for the final run output.

Parameters:

thread_id (str) – The ID of the thread. (required)
run_create_stateful (RunCreateStateful) – (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

async create_thread_run_with_http_info(thread_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the thread.')], run_create_stateful: RunCreateStateful, _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → ApiResponse[RunStateful]

Create a Background Run on a thread

Create a run on a thread, return the run ID immediately. Don’t wait for the final run output.

Parameters:

thread_id (str) – The ID of the thread. (required)
run_create_stateful (RunCreateStateful) – (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

async create_thread_run_without_preload_content(thread_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the thread.')], run_create_stateful: RunCreateStateful, _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → ClientResponse

Create a Background Run on a thread

Create a run on a thread, return the run ID immediately. Don’t wait for the final run output.

Parameters:

thread_id (str) – The ID of the thread. (required)
run_create_stateful (RunCreateStateful) – (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

async create_thread_with_http_info(thread_create: ThreadCreate, _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → ApiResponse[Thread]

Create an empty Thread

Create a new thread.

Parameters:

thread_create (ThreadCreate) – (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

async create_thread_without_preload_content(thread_create: ThreadCreate, _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → ClientResponse

Create an empty Thread

Create a new thread.

Parameters:

thread_create (ThreadCreate) – (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

async delete_stateless_run(run_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the run.')], _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → None

Delete Stateless Run

Delete a stateless run by ID.

Parameters:

run_id (str) – The ID of the run. (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

async delete_stateless_run_with_http_info(run_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the run.')], _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → ApiResponse[NoneType]

Delete Stateless Run

Delete a stateless run by ID.

Parameters:

run_id (str) – The ID of the run. (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

async delete_stateless_run_without_preload_content(run_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the run.')], _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → ClientResponse

Delete Stateless Run

Delete a stateless run by ID.

Parameters:

run_id (str) – The ID of the run. (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

async delete_thread(thread_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the thread.')], _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → None

Delete a thread. If the thread contains any pending run, deletion fails.

Delete a thread.

Parameters:

thread_id (str) – The ID of the thread. (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

async delete_thread_run(thread_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the thread.')], run_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the run.')], _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → None

Delete Run

Delete a run by ID.

Parameters:

thread_id (str) – The ID of the thread. (required)
run_id (str) – The ID of the run. (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

async delete_thread_run_with_http_info(thread_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the thread.')], run_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the run.')], _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → ApiResponse[NoneType]

Delete Run

Delete a run by ID.

Parameters:

thread_id (str) – The ID of the thread. (required)
run_id (str) – The ID of the run. (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

async delete_thread_run_without_preload_content(thread_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the thread.')], run_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the run.')], _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → ClientResponse

Delete Run

Delete a run by ID.

Parameters:

thread_id (str) – The ID of the thread. (required)
run_id (str) – The ID of the run. (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

async delete_thread_with_http_info(thread_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the thread.')], _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → ApiResponse[NoneType]

Delete a thread. If the thread contains any pending run, deletion fails.

Delete a thread.

Parameters:

thread_id (str) – The ID of the thread. (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

async delete_thread_without_preload_content(thread_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the thread.')], _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → ClientResponse

Delete a thread. If the thread contains any pending run, deletion fails.

Delete a thread.

Parameters:

thread_id (str) – The ID of the thread. (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

async get_acp_descriptor_by_id(agent_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the agent.')], _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → AgentACPDescriptor

Get Agent ACP Descriptor from its id

Get agent ACP descriptor by agent ID.

Parameters:

agent_id (str) – The ID of the agent. (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

async get_acp_descriptor_by_id_with_http_info(agent_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the agent.')], _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → ApiResponse[AgentACPDescriptor]

Get Agent ACP Descriptor from its id

Get agent ACP descriptor by agent ID.

Parameters:

agent_id (str) – The ID of the agent. (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

async get_acp_descriptor_by_id_without_preload_content(agent_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the agent.')], _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → ClientResponse

Get Agent ACP Descriptor from its id

Get agent ACP descriptor by agent ID.

Parameters:

agent_id (str) – The ID of the agent. (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

async get_agent_by_id(agent_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the agent.')], _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → Agent

Get Agent

Get an agent by ID.

Parameters:

agent_id (str) – The ID of the agent. (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

async get_agent_by_id_with_http_info(agent_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the agent.')], _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → ApiResponse[Agent]

Get Agent

Get an agent by ID.

Parameters:

agent_id (str) – The ID of the agent. (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

async get_agent_by_id_without_preload_content(agent_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the agent.')], _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → ClientResponse

Get Agent

Get an agent by ID.

Parameters:

agent_id (str) – The ID of the agent. (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

async get_stateless_run(run_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the run.')], _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → RunStateless

Get Run

Get a stateless run by ID.

Parameters:

run_id (str) – The ID of the run. (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

async get_stateless_run_with_http_info(run_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the run.')], _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → ApiResponse[RunStateless]

Get Run

Get a stateless run by ID.

Parameters:

run_id (str) – The ID of the run. (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

async get_stateless_run_without_preload_content(run_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the run.')], _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → ClientResponse

Get Run

Get a stateless run by ID.

Parameters:

run_id (str) – The ID of the run. (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

async get_thread(thread_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the thread.')], _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → Thread

Get Thread

Get a thread from its ID.

Parameters:

thread_id (str) – The ID of the thread. (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

async get_thread_history(thread_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the thread.')], limit: Annotated[int, Strict(strict=True)] | None = None, before: Annotated[str, Strict(strict=True)] | None = None, _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → List[ThreadState]

Get Thread History

Get all past states for a thread.

Parameters:

thread_id (str) – The ID of the thread. (required)
limit (int)
before (str)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

async get_thread_history_with_http_info(thread_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the thread.')], limit: Annotated[int, Strict(strict=True)] | None = None, before: Annotated[str, Strict(strict=True)] | None = None, _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → ApiResponse[List[ThreadState]]

Get Thread History

Get all past states for a thread.

Parameters:

thread_id (str) – The ID of the thread. (required)
limit (int)
before (str)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

async get_thread_history_without_preload_content(thread_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the thread.')], limit: Annotated[int, Strict(strict=True)] | None = None, before: Annotated[str, Strict(strict=True)] | None = None, _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → ClientResponse

Get Thread History

Get all past states for a thread.

Parameters:

thread_id (str) – The ID of the thread. (required)
limit (int)
before (str)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

async get_thread_run(thread_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the thread.')], run_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the run.')], _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → RunStateful

Get Run

Get a run by ID.

Parameters:

thread_id (str) – The ID of the thread. (required)
run_id (str) – The ID of the run. (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

async get_thread_run_with_http_info(thread_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the thread.')], run_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the run.')], _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → ApiResponse[RunStateful]

Get Run

Get a run by ID.

Parameters:

thread_id (str) – The ID of the thread. (required)
run_id (str) – The ID of the run. (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

async get_thread_run_without_preload_content(thread_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the thread.')], run_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the run.')], _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → ClientResponse

Get Run

Get a run by ID.

Parameters:

thread_id (str) – The ID of the thread. (required)
run_id (str) – The ID of the run. (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

async get_thread_with_http_info(thread_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the thread.')], _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → ApiResponse[Thread]

Get Thread

Get a thread from its ID.

Parameters:

thread_id (str) – The ID of the thread. (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

async get_thread_without_preload_content(thread_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the thread.')], _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → ClientResponse

Get Thread

Get a thread from its ID.

Parameters:

thread_id (str) – The ID of the thread. (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

async list_thread_runs(thread_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the thread.')], limit: Annotated[int, Strict(strict=True)] | None = None, offset: Annotated[int, Strict(strict=True)] | None = None, _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → List[RunStateful]

List Runs for a thread

List runs for a thread.

Parameters:

thread_id (str) – The ID of the thread. (required)
limit (int)
offset (int)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

async list_thread_runs_with_http_info(thread_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the thread.')], limit: Annotated[int, Strict(strict=True)] | None = None, offset: Annotated[int, Strict(strict=True)] | None = None, _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → ApiResponse[List[RunStateful]]

List Runs for a thread

List runs for a thread.

Parameters:

thread_id (str) – The ID of the thread. (required)
limit (int)
offset (int)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

async list_thread_runs_without_preload_content(thread_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the thread.')], limit: Annotated[int, Strict(strict=True)] | None = None, offset: Annotated[int, Strict(strict=True)] | None = None, _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → ClientResponse

List Runs for a thread

List runs for a thread.

Parameters:

thread_id (str) – The ID of the thread. (required)
limit (int)
offset (int)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

async patch_thread(thread_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the thread.')], thread_patch: ThreadPatch, _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → Thread

Patch Thread

Update a thread.

Parameters:

thread_id (str) – The ID of the thread. (required)
thread_patch (ThreadPatch) – (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

async patch_thread_with_http_info(thread_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the thread.')], thread_patch: ThreadPatch, _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → ApiResponse[Thread]

Patch Thread

Update a thread.

Parameters:

thread_id (str) – The ID of the thread. (required)
thread_patch (ThreadPatch) – (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

async patch_thread_without_preload_content(thread_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the thread.')], thread_patch: ThreadPatch, _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → ClientResponse

Patch Thread

Update a thread.

Parameters:

thread_id (str) – The ID of the thread. (required)
thread_patch (ThreadPatch) – (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

async resume_stateless_run(run_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the run.')], body: Dict[str, Any], _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → RunStateless

Resume an interrupted Run

Provide the needed input to a run to resume its execution. Can only be called for runs that are in the interrupted state Schema of the provided input must match with the schema specified in the agent specs under interrupts for the interrupt type the agent generated for this specific interruption.

Parameters:

run_id (str) – The ID of the run. (required)
body (object) – (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

async resume_stateless_run_with_http_info(run_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the run.')], body: Dict[str, Any], _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → ApiResponse[RunStateless]

Resume an interrupted Run

Provide the needed input to a run to resume its execution. Can only be called for runs that are in the interrupted state Schema of the provided input must match with the schema specified in the agent specs under interrupts for the interrupt type the agent generated for this specific interruption.

Parameters:

run_id (str) – The ID of the run. (required)
body (object) – (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

async resume_stateless_run_without_preload_content(run_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the run.')], body: Dict[str, Any], _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → ClientResponse

Resume an interrupted Run

Provide the needed input to a run to resume its execution. Can only be called for runs that are in the interrupted state Schema of the provided input must match with the schema specified in the agent specs under interrupts for the interrupt type the agent generated for this specific interruption.

Parameters:

run_id (str) – The ID of the run. (required)
body (object) – (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

async resume_thread_run(thread_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the thread.')], run_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the run.')], body: Dict[str, Any], _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → RunStateful

Resume an interrupted Run

Provide the needed input to a run to resume its execution. Can only be called for runs that are in the interrupted state Schema of the provided input must match with the schema specified in the agent specs under interrupts for the interrupt type the agent generated for this specific interruption.

Parameters:

thread_id (str) – The ID of the thread. (required)
run_id (str) – The ID of the run. (required)
body (object) – (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

async resume_thread_run_with_http_info(thread_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the thread.')], run_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the run.')], body: Dict[str, Any], _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → ApiResponse[RunStateful]

Resume an interrupted Run

Provide the needed input to a run to resume its execution. Can only be called for runs that are in the interrupted state Schema of the provided input must match with the schema specified in the agent specs under interrupts for the interrupt type the agent generated for this specific interruption.

Parameters:

thread_id (str) – The ID of the thread. (required)
run_id (str) – The ID of the run. (required)
body (object) – (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

async resume_thread_run_without_preload_content(thread_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the thread.')], run_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the run.')], body: Dict[str, Any], _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → ClientResponse

Resume an interrupted Run

Provide the needed input to a run to resume its execution. Can only be called for runs that are in the interrupted state Schema of the provided input must match with the schema specified in the agent specs under interrupts for the interrupt type the agent generated for this specific interruption.

Parameters:

thread_id (str) – The ID of the thread. (required)
run_id (str) – The ID of the run. (required)
body (object) – (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

async search_agents(agent_search_request: AgentSearchRequest, _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → List[Agent]

Search Agents

Returns a list of agents matching the criteria provided in the request. This endpoint also functions as the endpoint to list all agents.

Parameters:

agent_search_request (AgentSearchRequest) – (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

async search_agents_with_http_info(agent_search_request: AgentSearchRequest, _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → ApiResponse[List[Agent]]

Search Agents

Returns a list of agents matching the criteria provided in the request. This endpoint also functions as the endpoint to list all agents.

Parameters:

agent_search_request (AgentSearchRequest) – (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

async search_agents_without_preload_content(agent_search_request: AgentSearchRequest, _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → ClientResponse

Search Agents

Returns a list of agents matching the criteria provided in the request. This endpoint also functions as the endpoint to list all agents.

Parameters:

agent_search_request (AgentSearchRequest) – (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

async search_stateless_runs(run_search_request: RunSearchRequest, _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → List[RunStateless]

Search Stateless Runs

Search for stateless run. This endpoint also functions as the endpoint to list all stateless Runs.

Parameters:

run_search_request (RunSearchRequest) – (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

async search_stateless_runs_with_http_info(run_search_request: RunSearchRequest, _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → ApiResponse[List[RunStateless]]

Search Stateless Runs

Search for stateless run. This endpoint also functions as the endpoint to list all stateless Runs.

Parameters:

run_search_request (RunSearchRequest) – (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

async search_stateless_runs_without_preload_content(run_search_request: RunSearchRequest, _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → ClientResponse

Search Stateless Runs

Search for stateless run. This endpoint also functions as the endpoint to list all stateless Runs.

Parameters:

run_search_request (RunSearchRequest) – (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

async search_threads(thread_search_request: ThreadSearchRequest, _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → List[Thread]

Search Threads

Search for threads. This endpoint also functions as the endpoint to list all threads.

Parameters:

thread_search_request (ThreadSearchRequest) – (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

async search_threads_with_http_info(thread_search_request: ThreadSearchRequest, _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → ApiResponse[List[Thread]]

Search Threads

Search for threads. This endpoint also functions as the endpoint to list all threads.

Parameters:

thread_search_request (ThreadSearchRequest) – (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

async search_threads_without_preload_content(thread_search_request: ThreadSearchRequest, _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → ClientResponse

Search Threads

Search for threads. This endpoint also functions as the endpoint to list all threads.

Parameters:

thread_search_request (ThreadSearchRequest) – (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

async stream_stateless_run_output(run_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the run.')], _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → RunOutputStream

Stream output from Stateless Run

Join the output stream of an existing run. This endpoint streams output in real-time from a run. Only output produced after this endpoint is called will be streamed.

Parameters:

run_id (str) – The ID of the run. (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

async stream_stateless_run_output_with_http_info(run_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the run.')], _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → ApiResponse[RunOutputStream]

Stream output from Stateless Run

Join the output stream of an existing run. This endpoint streams output in real-time from a run. Only output produced after this endpoint is called will be streamed.

Parameters:

run_id (str) – The ID of the run. (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

async stream_stateless_run_output_without_preload_content(run_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the run.')], _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → ClientResponse

Stream output from Stateless Run

Join the output stream of an existing run. This endpoint streams output in real-time from a run. Only output produced after this endpoint is called will be streamed.

Parameters:

run_id (str) – The ID of the run. (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

async stream_thread_run_output(thread_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the thread.')], run_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the run.')], _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → RunOutputStream

Stream output from Run

Join the output stream of an existing run. See ‘GET /runs/{run_id}/stream’ for details on the return values.

Parameters:

thread_id (str) – The ID of the thread. (required)
run_id (str) – The ID of the run. (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

async stream_thread_run_output_with_http_info(thread_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the thread.')], run_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the run.')], _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → ApiResponse[RunOutputStream]

Stream output from Run

Join the output stream of an existing run. See ‘GET /runs/{run_id}/stream’ for details on the return values.

Parameters:

thread_id (str) – The ID of the thread. (required)
run_id (str) – The ID of the run. (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

async stream_thread_run_output_without_preload_content(thread_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the thread.')], run_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the run.')], _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → ClientResponse

Stream output from Run

Join the output stream of an existing run. See ‘GET /runs/{run_id}/stream’ for details on the return values.

Parameters:

thread_id (str) – The ID of the thread. (required)
run_id (str) – The ID of the run. (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

async wait_for_stateless_run_output(run_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the run.')], _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → RunWaitResponseStateless

Blocks waiting for the result of the run.

Blocks waiting for the result of the run. The output can be: * an interrupt, this happens when the agent run status is interrupted * the final result of the run, this happens when the agent run status is success * an error, this happens when the agent run status is error or timeout This call blocks until the output is available.

Parameters:

run_id (str) – The ID of the run. (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

async wait_for_stateless_run_output_with_http_info(run_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the run.')], _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → ApiResponse[RunWaitResponseStateless]

Blocks waiting for the result of the run.

Blocks waiting for the result of the run. The output can be: * an interrupt, this happens when the agent run status is interrupted * the final result of the run, this happens when the agent run status is success * an error, this happens when the agent run status is error or timeout This call blocks until the output is available.

Parameters:

run_id (str) – The ID of the run. (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

async wait_for_stateless_run_output_without_preload_content(run_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the run.')], _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → ClientResponse

Blocks waiting for the result of the run.

Blocks waiting for the result of the run. The output can be: * an interrupt, this happens when the agent run status is interrupted * the final result of the run, this happens when the agent run status is success * an error, this happens when the agent run status is error or timeout This call blocks until the output is available.

Parameters:

run_id (str) – The ID of the run. (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

async wait_for_thread_run_output(thread_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the thread.')], run_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the run.')], _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → RunWaitResponseStateful

Blocks waiting for the result of the run.

Blocks waiting for the result of the run. See ‘GET /runs/{run_id}/wait’ for details on the return values.

Parameters:

thread_id (str) – The ID of the thread. (required)
run_id (str) – The ID of the run. (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

async wait_for_thread_run_output_with_http_info(thread_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the thread.')], run_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the run.')], _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → ApiResponse[RunWaitResponseStateful]

Blocks waiting for the result of the run.

Blocks waiting for the result of the run. See ‘GET /runs/{run_id}/wait’ for details on the return values.

Parameters:

thread_id (str) – The ID of the thread. (required)
run_id (str) – The ID of the run. (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

async wait_for_thread_run_output_without_preload_content(thread_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the thread.')], run_id: Annotated[str, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, description='The ID of the run.')], _request_timeout: None | Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])] | Tuple[Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])], Annotated[float, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Gt(gt=0)])]] = None, _request_auth: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _content_type: Annotated[str, Strict(strict=True)] | None = None, _headers: Dict[Annotated[str, Strict(strict=True)], Any] | None = None, _host_index: Annotated[int, Strict(strict=True), FieldInfo(annotation=NoneType, required=True, metadata=[Ge(ge=0), Le(le=0)])] = 0) → ClientResponse

Blocks waiting for the result of the run.

Blocks waiting for the result of the run. See ‘GET /runs/{run_id}/wait’ for details on the return values.

Parameters:

thread_id (str) – The ID of the thread. (required)
run_id (str) – The ID of the run. (required)
_request_timeout (int, tuple(int, int), optional) – timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts.
_request_auth (dict, optional) – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.
_content_type (str, Optional) – force content-type for the request.
_headers (dict, optional) – set to override the headers for a single request; this effectively ignores the headers in the spec for a single request.
_host_index (int, optional) – set to override the host_index for a single request; this effectively ignores the host_index in the spec for a single request.

Returns:

Returns the result object.

`ApiClient`

class agntcy_acp.ApiClient(configuration=None, header_name=None, header_value=None, cookie=None)

Generic API client for OpenAPI client library builds.

OpenAPI generic API client. This client handles the client- server communication, and is invariant across implementations. Specifics of the methods and models for each application are generated from the OpenAPI templates.

Parameters:

configuration – .Configuration object for this client
header_name – a header to pass when making calls to the API.
header_value – a header value to pass when making calls to the API.
cookie – a cookie to include in the header when making calls to the API

call_api(method, url, header_params=None, body=None, post_params=None, _request_timeout=None) → RESTResponse

Makes the HTTP request (synchronous) :param method: Method to call. :param url: Path to method endpoint. :param header_params: Header parameters to be

placed in the request header.

Parameters:

body – Request body.
dict (post_params) – Request post form parameters, for application/x-www-form-urlencoded, multipart/form-data.
_request_timeout – timeout setting for this request.

Returns:

RESTResponse

deserialize(response_text: str, response_type: str, content_type: str | None)

Deserializes response into an object.

Parameters:

response – RESTResponse object to be deserialized.
response_type – class literal for deserialized object, or string of class name.
content_type – content type of response.

Returns:

deserialized object.

files_parameters(files: Dict[str, str | bytes | List[str] | List[bytes] | Tuple[str, bytes]])

Builds form parameters.

Parameters:: files – File parameters.
Returns:: Form parameters with files.

classmethod get_default()

Return new instance of ApiClient.

This method returns newly created, based on default constructor, object of ApiClient class or returns a copy of default ApiClient.

Returns:: The ApiClient object.

param_serialize(method, resource_path, path_params=None, query_params=None, header_params=None, body=None, post_params=None, files=None, auth_settings=None, collection_formats=None, _host=None, _request_auth=None) → Tuple[str, str, Dict[str, str], str | None, List[str]]

Builds the HTTP request params needed by the request. :param method: Method to call. :param resource_path: Path to method endpoint. :param path_params: Path parameters in the url. :param query_params: Query parameters in the url. :param header_params: Header parameters to be

placed in the request header.

Parameters:

body – Request body.
dict (files) – Request post form parameters, for application/x-www-form-urlencoded, multipart/form-data.
list (auth_settings) – Auth Settings names for the request.
dict – key -> filename, value -> filepath, for multipart/form-data.
collection_formats – dict of collection formats for path, query, header, and post parameters.
_request_auth – set to override the auth_settings for an a single request; this effectively ignores the authentication in the spec for a single request.

Returns:

tuple of form (path, http_method, query_params, header_params, body, post_params, files)

parameters_to_tuples(params, collection_formats)

Get parameters as list of tuples, formatting collections.

Parameters:

params – Parameters as dict or list of two-tuples
collection_formats (dict) – Parameter collection formats

Returns:

Parameters as list of tuples, collections formatted

parameters_to_url_query(params, collection_formats)

Get parameters as list of tuples, formatting collections.

Parameters:

params – Parameters as dict or list of two-tuples
collection_formats (dict) – Parameter collection formats

Returns:

URL query string (e.g. a=Hello%20World&b=123)

response_deserialize(response_data: RESTResponse, response_types_map: Dict[str, T] | None = None) → ApiResponse: Deserializes response into an object. :param response_data: RESTResponse object to be deserialized. :param response_types_map: dict of response types. :return: ApiResponse

sanitize_for_serialization(obj)

Builds a JSON POST object.

If obj is None, return None. If obj is SecretStr, return obj.get_secret_value() If obj is str, int, long, float, bool, return directly. If obj is datetime.datetime, datetime.date

convert to string in iso8601 format.

If obj is decimal.Decimal return string representation. If obj is list, sanitize each element in the list. If obj is dict, return the dict. If obj is OpenAPI model, return the properties dict.

Parameters:: obj – The data to serialize.
Returns:: The serialized form of data.

select_header_accept(accepts: List[str]) → str | None

Returns Accept based on an array of accepts provided.

Parameters:: accepts – List of headers.
Returns:: Accept (e.g. application/json).

select_header_content_type(content_types)

Returns Content-Type based on an array of content_types provided.

Parameters:: content_types – List of content-types.
Returns:: Content-Type (e.g. application/json).

classmethod set_default(default)

Set default instance of ApiClient.

It stores default ApiClient.

Parameters:: default – object of ApiClient.

update_params_for_auth(headers, queries, auth_settings, resource_path, method, body, request_auth=None) → None

Updates header and query params based on authentication setting.

Parameters:

headers – Header parameters dict to be updated.
queries – Query parameters tuple list to be updated.
auth_settings – Authentication setting identifiers list.

Resource_path:

A string representation of the HTTP request resource path.

Method:

A string representation of the HTTP request method.

Body:

A object representing the body of the HTTP request.

The object type is the return value of sanitize_for_serialization(). :param request_auth: if set, the provided settings will

override the token in the configuration.

property user_agent: User agent for this API client

`AsyncApiClient`

agntcy_acp.AsyncApiClient: alias of ApiClient

`ApiResponse`

pydantic model agntcy_acp.ApiResponse

API response object

Show JSON schema

{
   "title": "ApiResponse",
   "description": "API response object",
   "type": "object",
   "properties": {
      "status_code": {
         "description": "HTTP status code",
         "title": "Status Code",
         "type": "integer"
      },
      "headers": {
         "anyOf": [
            {
               "additionalProperties": {
                  "type": "string"
               },
               "type": "object"
            },
            {
               "type": "null"
            }
         ],
         "default": null,
         "description": "HTTP headers",
         "title": "Headers"
      },
      "data": {
         "description": "Deserialized data given the data type",
         "title": "Data"
      },
      "raw_data": {
         "description": "Raw data (HTTP response body)",
         "format": "binary",
         "title": "Raw Data",
         "type": "string"
      }
   },
   "required": [
      "status_code",
      "data",
      "raw_data"
   ]
}

Config:

arbitrary_types_allowed: bool = True

Fields:

data (agntcy_acp.acp_v0.api_response.T)
headers (Mapping[str, str] | None)
raw_data (bytes)
status_code (int)

field data: T [Required]: Deserialized data given the data type

field headers: Mapping[str, str] | None = None: HTTP headers

field raw_data: StrictBytes [Required]

Raw data (HTTP response body)

Constraints:

strict = True

field status_code: StrictInt [Required]

HTTP status code

Constraints:

strict = True

LangGraph Bindings

`ACPNode`

class agntcy_acp.langgraph.ACPNode(name: str, agent_id: str, client_config: ApiClientConfiguration, input_path: str, input_type, output_path: str, output_type, config_path: str | None = None, config_type=None, auth_header: dict | None = None)

This class represents a Langgraph Node that holds a remote connection to an ACP Agent It can be instantiated and added to any langgraph graph.

my_node = ACPNode(…) sg = StateGraph(GraphState) sg.add_node(my_node)

`APIBridgeAgentNode`

class agntcy_acp.langgraph.APIBridgeAgentNode(name: str, hostname: str, service_name: str, input_path: str, output_path: str, service_api_key: str, input_type: ~typing.Any = <class 'agntcy_acp.langgraph.api_bridge.APIBridgeInput'>, output_type: ~typing.Any = <class 'agntcy_acp.langgraph.api_bridge.APIBridgeOutput'>, apikey: str | None = None): An ACP node that enables using remotely the API bridge agent in a LangGraph multi agent software

`APIBridgeInput`

pydantic model agntcy_acp.langgraph.APIBridgeInput

Show JSON schema

{
   "title": "APIBridgeInput",
   "type": "object",
   "properties": {
      "query": {
         "description": "Query for the API bridge agent in natural language",
         "title": "Query",
         "type": "string"
      }
   },
   "required": [
      "query"
   ]
}

Fields:

query (str)

field query: str [Required]: Query for the API bridge agent in natural language

`APIBridgeOutput`

pydantic model agntcy_acp.langgraph.APIBridgeOutput

Show JSON schema

{
   "title": "APIBridgeOutput",
   "type": "object",
   "properties": {
      "result": {
         "description": "API response from API bridge agent",
         "title": "Result",
         "type": "string"
      }
   },
   "required": [
      "result"
   ]
}

Fields:

result (str)

field result: str [Required]: API response from API bridge agent

`add_io_mapped_edge`

agntcy_acp.langgraph.add_io_mapped_edge(g: StateGraph, start: str | ACPNode, end: str | ACPNode, iomapper_config: IOMappingAgentMetadata, llm: BaseChatModel) → IOMappingAgent

Adds an I/O-mapped edge to a LangGraph StateGraph.

Parameters:: g: The LangGraph StateGraph to which the edge will be added. start: The starting node of the edge, which can be specified either as a string identifier or as an instance of an ACPNode. end: The ending node of the edge, which can be specified either as a string identifier or as an instance of an ACPNode. iomapper_config: A dictionary containing all the metadata necessary for the IO mapper agent to perform data translation. Defaults to an empty dictionary. llm: An instance of llm model
Returns:: None: This function modifies the graph in place by adding the specified edge.

`add_io_mapped_conditional_edge`

agntcy_acp.langgraph.add_io_mapped_conditional_edge(g: StateGraph, start: str | ACPNode, path, iomapper_config_map: dict, llm: BaseChatModel) → dict

Adds a conditional I/O-mapped edge to a LangGraph StateGraph.

Parameters:: g: The LangGraph StateGraph to which the conditional edge will be added. start: The starting node of the edge, which can be specified either as a string identifier or as an instance of an ACPNode. path: The conditional path that determines the conditions under which the edge will be traversed. The type and structure of ‘path’ should be specified based on its use case. iomapper_config_map: A dictionary containing metadata that the IO mapper agent requires for data translation. This map is used to configure the agent based on different conditions. llm: An instance of llm model
Returns:: None: This function modifies the graph in place by adding the specified conditional edge.

Exceptions

`ACPDescriptorValidationException`

class agntcy_acp.ACPDescriptorValidationException

add_note(): Exception.add_note(note) – add a note to the exception

with_traceback(): Exception.with_traceback(tb) – set self.__traceback__ to tb and return self.

`ACPRunException`

class agntcy_acp.ACPRunException

add_note(): Exception.add_note(note) – add a note to the exception

with_traceback(): Exception.with_traceback(tb) – set self.__traceback__ to tb and return self.

`ApiTypeError`

class agntcy_acp.ApiTypeError(msg, path_to_item=None, valid_classes=None, key_type=None)

add_note(): Exception.add_note(note) – add a note to the exception

with_traceback(): Exception.with_traceback(tb) – set self.__traceback__ to tb and return self.

`ApiValueError`

class agntcy_acp.ApiValueError(msg, path_to_item=None)

add_note(): Exception.add_note(note) – add a note to the exception

with_traceback(): Exception.with_traceback(tb) – set self.__traceback__ to tb and return self.

`ApiKeyError`

class agntcy_acp.ApiKeyError(msg, path_to_item=None)

add_note(): Exception.add_note(note) – add a note to the exception

with_traceback(): Exception.with_traceback(tb) – set self.__traceback__ to tb and return self.

`ApiAttributeError`

class agntcy_acp.ApiAttributeError(msg, path_to_item=None)

add_note(): Exception.add_note(note) – add a note to the exception

name: attribute name

obj: object

with_traceback(): Exception.with_traceback(tb) – set self.__traceback__ to tb and return self.

`ApiException`

class agntcy_acp.ApiException(status=None, reason=None, http_resp=None, *, body: str | None = None, data: Any | None = None)

add_note(): Exception.add_note(note) – add a note to the exception

with_traceback(): Exception.with_traceback(tb) – set self.__traceback__ to tb and return self.

`BadRequestException`

class agntcy_acp.BadRequestException(status=None, reason=None, http_resp=None, *, body: str | None = None, data: Any | None = None)

add_note(): Exception.add_note(note) – add a note to the exception

with_traceback(): Exception.with_traceback(tb) – set self.__traceback__ to tb and return self.

`NotFoundException`

class agntcy_acp.NotFoundException(status=None, reason=None, http_resp=None, *, body: str | None = None, data: Any | None = None)

add_note(): Exception.add_note(note) – add a note to the exception

with_traceback(): Exception.with_traceback(tb) – set self.__traceback__ to tb and return self.

`UnauthorizedException`

class agntcy_acp.UnauthorizedException(status=None, reason=None, http_resp=None, *, body: str | None = None, data: Any | None = None)

add_note(): Exception.add_note(note) – add a note to the exception

with_traceback(): Exception.with_traceback(tb) – set self.__traceback__ to tb and return self.

`ForbiddenException`

class agntcy_acp.ForbiddenException(status=None, reason=None, http_resp=None, *, body: str | None = None, data: Any | None = None)

add_note(): Exception.add_note(note) – add a note to the exception

with_traceback(): Exception.with_traceback(tb) – set self.__traceback__ to tb and return self.

`ServiceException`

class agntcy_acp.ServiceException(status=None, reason=None, http_resp=None, *, body: str | None = None, data: Any | None = None)

add_note(): Exception.add_note(note) – add a note to the exception

with_traceback(): Exception.with_traceback(tb) – set self.__traceback__ to tb and return self.

`ConflictException`

class agntcy_acp.ConflictException(status=None, reason=None, http_resp=None, *, body: str | None = None, data: Any | None = None)

Exception for HTTP 409 Conflict.

add_note(): Exception.add_note(note) – add a note to the exception

with_traceback(): Exception.with_traceback(tb) – set self.__traceback__ to tb and return self.

`UnprocessableEntityException`

class agntcy_acp.UnprocessableEntityException(status=None, reason=None, http_resp=None, *, body: str | None = None, data: Any | None = None)

Exception for HTTP 422 Unprocessable Entity.

add_note(): Exception.add_note(note) – add a note to the exception

with_traceback(): Exception.with_traceback(tb) – set self.__traceback__ to tb and return self.

`OpenApiException`

class agntcy_acp.OpenApiException

The base exception class for all OpenAPIExceptions

add_note(): Exception.add_note(note) – add a note to the exception

with_traceback(): Exception.with_traceback(tb) – set self.__traceback__ to tb and return self.

Client Reference API

ACP Objects

ApiClientConfiguration

ACPClient

AsyncACPClient

ApiClient

AsyncApiClient

ApiResponse

LangGraph Bindings

ACPNode

APIBridgeAgentNode

APIBridgeInput

APIBridgeOutput

add_io_mapped_edge

add_io_mapped_conditional_edge

Exceptions

ACPDescriptorValidationException

ACPRunException

ApiTypeError

ApiValueError

ApiKeyError

ApiAttributeError

ApiException

BadRequestException

NotFoundException

UnauthorizedException

ForbiddenException

ServiceException

ConflictException

UnprocessableEntityException

OpenApiException

`ApiClientConfiguration`

`ACPClient`

`AsyncACPClient`

`ApiClient`

`AsyncApiClient`

`ApiResponse`

`ACPNode`

`APIBridgeAgentNode`

`APIBridgeInput`

`APIBridgeOutput`

`add_io_mapped_edge`

`add_io_mapped_conditional_edge`

`ACPDescriptorValidationException`

`ACPRunException`

`ApiTypeError`

`ApiValueError`

`ApiKeyError`

`ApiAttributeError`

`ApiException`

`BadRequestException`

`NotFoundException`

`UnauthorizedException`

`ForbiddenException`

`ServiceException`

`ConflictException`

`UnprocessableEntityException`

`OpenApiException`