Interface GenerativeAiAsync

  • All Superinterfaces:
    AutoCloseable
    All Known Implementing Classes:
    GenerativeAiAsyncClient

    @Generated(value="OracleSDKGenerator",
               comments="API Version: 20231130")
    public interface GenerativeAiAsync
    extends AutoCloseable
    OCI Generative AI is a fully managed service that provides a set of state-of-the-art, customizable large language models (LLMs) that cover a wide range of use cases for text generation, summarization, and text embeddings.

    Use the Generative AI service management API to create and manage DedicatedAiCluster, Endpoint, Model, and WorkRequest in the Generative AI service. For example, create a custom model by fine-tuning an out-of-the-box model using your own data, on a fine-tuning dedicated AI cluster. Then, create a hosting dedicated AI cluster with an endpoint to host your custom model.

    To access your custom model endpoints, or to try the out-of-the-box models to generate text, summarize, and create text embeddings see the [Generative AI Inference API](https://docs.oracle.com/iaas/api/#/en/generative-ai-inference/latest/).

    To learn more about the service, see the [Generative AI documentation](https://docs.oracle.com/iaas/Content/generative-ai/home.htm).

    • Method Detail

      • refreshClient

        void refreshClient()
        Rebuilds the client from scratch.

        Useful to refresh certificates.

      • setEndpoint

        void setEndpoint​(String endpoint)
        Sets the endpoint to call (ex, https://www.example.com).
        Parameters:
        endpoint - The endpoint of the serice.
      • getEndpoint

        String getEndpoint()
        Gets the set endpoint for REST call (ex, https://www.example.com)
      • setRegion

        void setRegion​(Region region)
        Sets the region to call (ex, Region.US_PHOENIX_1).

        Note, this will call setEndpoint after resolving the endpoint. If the service is not available in this region, however, an IllegalArgumentException will be raised.

        Parameters:
        region - The region of the service.
      • setRegion

        void setRegion​(String regionId)
        Sets the region to call (ex, ‘us-phoenix-1’).

        Note, this will first try to map the region ID to a known Region and call setRegion.

        If no known Region could be determined, it will create an endpoint based on the default endpoint format (Region.formatDefaultRegionEndpoint(Service, String) and then call setEndpoint.

        Parameters:
        regionId - The public region ID.
      • useRealmSpecificEndpointTemplate

        void useRealmSpecificEndpointTemplate​(boolean realmSpecificEndpointTemplateEnabled)
        Determines whether realm specific endpoint should be used or not.

        Set realmSpecificEndpointTemplateEnabled to “true” if the user wants to enable use of realm specific endpoint template, otherwise set it to “false”

        Parameters:
        realmSpecificEndpointTemplateEnabled - flag to enable the use of realm specific endpoint template
      • enableDualStackEndpoints

        void enableDualStackEndpoints​(boolean dualStackEndpointTemplateEnabled)
        Determines whether dual stack endpoint should be used or not.

        Set dualStackEndpointTemplateEnabled to “true” if the user wants to enable use of dual stack endpoint template. Default value is “false”

        Parameters:
        dualStackEndpointTemplateEnabled - flag to enable the use of dual stack endpoint template
      • addArtifact

        Future<AddArtifactResponse> addArtifact​(AddArtifactRequest request,
                                                AsyncHandler<AddArtifactRequest,​AddArtifactResponse> handler)
        add image with isAutoDeploy flag.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • createApiKey

        Future<CreateApiKeyResponse> createApiKey​(CreateApiKeyRequest request,
                                                  AsyncHandler<CreateApiKeyRequest,​CreateApiKeyResponse> handler)
        Creates a new API key in the specified compartment.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • createEndpoint

        Future<CreateEndpointResponse> createEndpoint​(CreateEndpointRequest request,
                                                      AsyncHandler<CreateEndpointRequest,​CreateEndpointResponse> handler)
        Creates an endpoint.

        The header contains an opc-work-request-id, which is the id for the WorkRequest that tracks the endpoint creation progress.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • createGenerativeAiProject

        Future<CreateGenerativeAiProjectResponse> createGenerativeAiProject​(CreateGenerativeAiProjectRequest request,
                                                                            AsyncHandler<CreateGenerativeAiProjectRequest,​CreateGenerativeAiProjectResponse> handler)
        Creates a GenerativeAiProject.

        The header contains an opc-work-request-id, which is the id for the WorkRequest that tracks the generativeAiProject creation progress.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • createImportedModel

        Future<CreateImportedModelResponse> createImportedModel​(CreateImportedModelRequest request,
                                                                AsyncHandler<CreateImportedModelRequest,​CreateImportedModelResponse> handler)
        Import a model from ModelDataSource.

        The header contains an opc-work-request-id, which is the id for the WorkRequest that tracks the importedModel creation progress.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • createModel

        Future<CreateModelResponse> createModel​(CreateModelRequest request,
                                                AsyncHandler<CreateModelRequest,​CreateModelResponse> handler)
        Creates a custom model by fine-tuning a base model with your own dataset.

        You can create a new custom models or create a new version of existing custom model..

        The header contains an opc-work-request-id, which is the id for the WorkRequest that tracks the model creation progress.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • createRoutingProfile

        Future<CreateRoutingProfileResponse> createRoutingProfile​(CreateRoutingProfileRequest request,
                                                                  AsyncHandler<CreateRoutingProfileRequest,​CreateRoutingProfileResponse> handler)
        Creates a routing profile.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • createSandboxWarmPool

        Future<CreateSandboxWarmPoolResponse> createSandboxWarmPool​(CreateSandboxWarmPoolRequest request,
                                                                    AsyncHandler<CreateSandboxWarmPoolRequest,​CreateSandboxWarmPoolResponse> handler)
        Creates a named MANAGED or CUSTOM pool.

        MANAGED uses the service-provided python-3.11 runtime and requires containerImage to be omitted. CUSTOM requires a digest-pinned containerImage. Project-wide shape capacity limits include named pools of both types and reserved default pools. Type, image, shape and name are immutable. The CP atomically persists CREATING and a Work Request, then its workflow prepares an immutable pool-owned template and applies the pool configuration. Each MANAGED pool has a distinct template based on the service runtime configuration, isolated from other pools of the same shape. ACTIVE means configuration was applied and verified; it does not require ready members, a successful image boot or available cluster capacity. Zero capacity pauses idle prewarming. An ACTIVE named pool can still create Sandboxes through cold fallback when its applied template is available. Retry identity and configuration are persisted atomically. Within the 24-hour retry-token validity period, the same token and input identify the original pool id, including after name reuse. A retry never creates or selects a replacement pool. A retry after the original pool is deleted returns 409; changed input with the same token conflicts. Reserved default names cannot be reused for either type.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • createSemanticStore

        Future<CreateSemanticStoreResponse> createSemanticStore​(CreateSemanticStoreRequest request,
                                                                AsyncHandler<CreateSemanticStoreRequest,​CreateSemanticStoreResponse> handler)
        Creates a SemanticStore.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • createVectorStoreConnector

        Future<CreateVectorStoreConnectorResponse> createVectorStoreConnector​(CreateVectorStoreConnectorRequest request,
                                                                              AsyncHandler<CreateVectorStoreConnectorRequest,​CreateVectorStoreConnectorResponse> handler)
        Creates a VectorStoreConnector.

        The header contains an opc-work-request-id, which is the id for the WorkRequest that tracks the vectorStoreConnector creation progress.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • createVectorStoreConnectorFileSync

        Future<CreateVectorStoreConnectorFileSyncResponse> createVectorStoreConnectorFileSync​(CreateVectorStoreConnectorFileSyncRequest request,
                                                                                              AsyncHandler<CreateVectorStoreConnectorFileSyncRequest,​CreateVectorStoreConnectorFileSyncResponse> handler)
        Creates a File Sync operation for a VectorStoreConnector.

        The header contains an opc-work-request-id, which is the id for the WorkRequest that tracks the vectorStoreConnectorFileSync creation progress.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • deleteApiKey

        Future<DeleteApiKeyResponse> deleteApiKey​(DeleteApiKeyRequest request,
                                                  AsyncHandler<DeleteApiKeyRequest,​DeleteApiKeyResponse> handler)
        Deletes an API key.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • deleteDedicatedAiCluster

        Future<DeleteDedicatedAiClusterResponse> deleteDedicatedAiCluster​(DeleteDedicatedAiClusterRequest request,
                                                                          AsyncHandler<DeleteDedicatedAiClusterRequest,​DeleteDedicatedAiClusterResponse> handler)
        Deletes a dedicated AI cluster.

        You can only delete clusters without attached resources. Before you delete a hosting dedicated AI cluster, you must delete the endpoints associated to that cluster. Before you delete a fine-tuning dedicated AI cluster, you must delete the custom model on that cluster. The delete action permanently deletes the cluster. This action can't be undone.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • deleteEndpoint

        Future<DeleteEndpointResponse> deleteEndpoint​(DeleteEndpointRequest request,
                                                      AsyncHandler<DeleteEndpointRequest,​DeleteEndpointResponse> handler)
        Deletes an endpoint.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • deleteHostedApplication

        Future<DeleteHostedApplicationResponse> deleteHostedApplication​(DeleteHostedApplicationRequest request,
                                                                        AsyncHandler<DeleteHostedApplicationRequest,​DeleteHostedApplicationResponse> handler)
        Deletes a hosted application.

        You can only delete hosted application without attached resources. Before you delete a hosting hosted application, you must delete the endpoints associated to that application. Before you delete a fine-tuning hosted application, you must delete the custom model on that application. The delete action permanently deletes the cluster. This action can’t be undone.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • deleteHostedApplicationIam

        Future<DeleteHostedApplicationIamResponse> deleteHostedApplicationIam​(DeleteHostedApplicationIamRequest request,
                                                                              AsyncHandler<DeleteHostedApplicationIamRequest,​DeleteHostedApplicationIamResponse> handler)
        Deletes a hosted application.

        You can only delete hosted application without attached resources. Before you delete a hosting hosted application, you must delete the endpoints associated to that application. Before you delete a fine-tuning hosted application, you must delete the custom model on that application. The delete action permanently deletes the cluster. This action can’t be undone.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • deleteHostedApplicationStorage

        Future<DeleteHostedApplicationStorageResponse> deleteHostedApplicationStorage​(DeleteHostedApplicationStorageRequest request,
                                                                                      AsyncHandler<DeleteHostedApplicationStorageRequest,​DeleteHostedApplicationStorageResponse> handler)
        Deletes a hosted application.

        You can only delete hosted application without attached resources. Before you delete a hosting hosted application, you must delete the endpoints associated to that application. Before you delete a fine-tuning hosted application, you must delete the custom model on that application. The delete action permanently deletes the cluster. This action can’t be undone.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • deleteHostedDeployment

        Future<DeleteHostedDeploymentResponse> deleteHostedDeployment​(DeleteHostedDeploymentRequest request,
                                                                      AsyncHandler<DeleteHostedDeploymentRequest,​DeleteHostedDeploymentResponse> handler)
        Deletes a hosted deployment.

        You can only delete hosted deployment without attached resources. Before you delete a hosting hosted deployment, you must delete the endpoints associated to that deployment. Before you delete a fine-tuning hosted deployment, you must delete the custom model on that deployment. The delete action permanently deletes the cluster. This action can’t be undone.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • deleteImportedModel

        Future<DeleteImportedModelResponse> deleteImportedModel​(DeleteImportedModelRequest request,
                                                                AsyncHandler<DeleteImportedModelRequest,​DeleteImportedModelResponse> handler)
        Deletes an imported model.

        An imported model shouldn’t be deleted if there’s one or more active endpoints associated with that imported model.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • deleteModel

        Future<DeleteModelResponse> deleteModel​(DeleteModelRequest request,
                                                AsyncHandler<DeleteModelRequest,​DeleteModelResponse> handler)
        Deletes a custom model.

        A model shouldn’t be deleted if there’s one or more active endpoints associated with that model.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • deleteRoutingProfile

        Future<DeleteRoutingProfileResponse> deleteRoutingProfile​(DeleteRoutingProfileRequest request,
                                                                  AsyncHandler<DeleteRoutingProfileRequest,​DeleteRoutingProfileResponse> handler)
        Deletes a routing profile.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • deleteSandboxWarmPool

        Future<DeleteSandboxWarmPoolResponse> deleteSandboxWarmPool​(DeleteSandboxWarmPoolRequest request,
                                                                    AsyncHandler<DeleteSandboxWarmPoolRequest,​DeleteSandboxWarmPoolResponse> handler)
        Deletes a named MANAGED or CUSTOM pool through a CP Work Request.

        Reserved MANAGED default entries cannot be deleted and return 409. CP persists DELETING and closes admission as the new configuration propagates, drains idle members and deletes the pool resource. The management response does not promise immediate global admission closure or completed cleanup. Already-adopted customer Sandboxes survive and retain required template dependencies. Get and List continue to show DELETING until pool cleanup completes. The CP then records DELETED and releases the name. Name reuse always allocates a new id and materialized names. Retained templates may outlive the pool while customer Sandboxes still depend on them. A repeated delete during DELETING returns the existing Work Request. A missing name returns 404. After name reuse, the path identifies the new pool; use the original if-match ETag to prevent deleting it. Conflicting operations return 409 and stale if-match returns 412.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • deleteSemanticStore

        Future<DeleteSemanticStoreResponse> deleteSemanticStore​(DeleteSemanticStoreRequest request,
                                                                AsyncHandler<DeleteSemanticStoreRequest,​DeleteSemanticStoreResponse> handler)
        Deletes a semanticStore.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • getApiKey

        Future<GetApiKeyResponse> getApiKey​(GetApiKeyRequest request,
                                            AsyncHandler<GetApiKeyRequest,​GetApiKeyResponse> handler)
        Gets information about an API key.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • getDedicatedAiCluster

        Future<GetDedicatedAiClusterResponse> getDedicatedAiCluster​(GetDedicatedAiClusterRequest request,
                                                                    AsyncHandler<GetDedicatedAiClusterRequest,​GetDedicatedAiClusterResponse> handler)
        Gets information about a dedicated AI cluster.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • getEndpoint

        Future<GetEndpointResponse> getEndpoint​(GetEndpointRequest request,
                                                AsyncHandler<GetEndpointRequest,​GetEndpointResponse> handler)
        Gets information about an endpoint.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • getGenerativeAiProject

        Future<GetGenerativeAiProjectResponse> getGenerativeAiProject​(GetGenerativeAiProjectRequest request,
                                                                      AsyncHandler<GetGenerativeAiProjectRequest,​GetGenerativeAiProjectResponse> handler)
        Gets information about a generativeAiProject.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • getHostedApplication

        Future<GetHostedApplicationResponse> getHostedApplication​(GetHostedApplicationRequest request,
                                                                  AsyncHandler<GetHostedApplicationRequest,​GetHostedApplicationResponse> handler)
        Gets information about a hosted application.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • getHostedApplicationIam

        Future<GetHostedApplicationIamResponse> getHostedApplicationIam​(GetHostedApplicationIamRequest request,
                                                                        AsyncHandler<GetHostedApplicationIamRequest,​GetHostedApplicationIamResponse> handler)
        Gets information about a hosted application.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • getHostedDeployment

        Future<GetHostedDeploymentResponse> getHostedDeployment​(GetHostedDeploymentRequest request,
                                                                AsyncHandler<GetHostedDeploymentRequest,​GetHostedDeploymentResponse> handler)
        Gets information about a hosted deployment.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • getImportedModel

        Future<GetImportedModelResponse> getImportedModel​(GetImportedModelRequest request,
                                                          AsyncHandler<GetImportedModelRequest,​GetImportedModelResponse> handler)
        Gets information about an imported model.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • getModel

        Future<GetModelResponse> getModel​(GetModelRequest request,
                                          AsyncHandler<GetModelRequest,​GetModelResponse> handler)
        Gets information about a custom model.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • getRoutingProfile

        Future<GetRoutingProfileResponse> getRoutingProfile​(GetRoutingProfileRequest request,
                                                            AsyncHandler<GetRoutingProfileRequest,​GetRoutingProfileResponse> handler)
        Gets information about a routing profile.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • getSandboxWarmPool

        Future<GetSandboxWarmPoolResponse> getSandboxWarmPool​(GetSandboxWarmPoolRequest request,
                                                              AsyncHandler<GetSandboxWarmPoolRequest,​GetSandboxWarmPoolResponse> handler)
        Gets authoritative CP configuration and management lifecycle for the current pool incarnation, including DELETING until pool cleanup completes.

        Returns 404 after deletion completes unless the name has been reused for a new id. A best-effort runtime observation may report ready idle capacity. A runtime read failure returns UNAVAILABLE without failing the configuration read. ACTIVE does not imply runtime capacity is ready. The configuration ETag excludes runtime changes; it must not be used to suppress runtime observations with a conditional not-modified response.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • getSemanticStore

        Future<GetSemanticStoreResponse> getSemanticStore​(GetSemanticStoreRequest request,
                                                          AsyncHandler<GetSemanticStoreRequest,​GetSemanticStoreResponse> handler)
        Gets information about a semanticStore.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • getVectorStoreConnector

        Future<GetVectorStoreConnectorResponse> getVectorStoreConnector​(GetVectorStoreConnectorRequest request,
                                                                        AsyncHandler<GetVectorStoreConnectorRequest,​GetVectorStoreConnectorResponse> handler)
        Gets information about a vectorStoreConnector.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • getWorkRequest

        Future<GetWorkRequestResponse> getWorkRequest​(GetWorkRequestRequest request,
                                                      AsyncHandler<GetWorkRequestRequest,​GetWorkRequestResponse> handler)
        Gets the details of a work request.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listApiKeys

        Future<ListApiKeysResponse> listApiKeys​(ListApiKeysRequest request,
                                                AsyncHandler<ListApiKeysRequest,​ListApiKeysResponse> handler)
        Lists the ApiKeys of a specific compartment.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listDedicatedAiClusters

        Future<ListDedicatedAiClustersResponse> listDedicatedAiClusters​(ListDedicatedAiClustersRequest request,
                                                                        AsyncHandler<ListDedicatedAiClustersRequest,​ListDedicatedAiClustersResponse> handler)
        Lists the dedicated AI clusters in a specific compartment.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listEndpoints

        Future<ListEndpointsResponse> listEndpoints​(ListEndpointsRequest request,
                                                    AsyncHandler<ListEndpointsRequest,​ListEndpointsResponse> handler)
        Lists the endpoints of a specific compartment.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listGenerativeAiProjects

        Future<ListGenerativeAiProjectsResponse> listGenerativeAiProjects​(ListGenerativeAiProjectsRequest request,
                                                                          AsyncHandler<ListGenerativeAiProjectsRequest,​ListGenerativeAiProjectsResponse> handler)
        Lists the generativeAiProjects of a specific compartment.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listHostedApplications

        Future<ListHostedApplicationsResponse> listHostedApplications​(ListHostedApplicationsRequest request,
                                                                      AsyncHandler<ListHostedApplicationsRequest,​ListHostedApplicationsResponse> handler)
        Lists the hosted applications in a specific compartment.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listHostedDeployments

        Future<ListHostedDeploymentsResponse> listHostedDeployments​(ListHostedDeploymentsRequest request,
                                                                    AsyncHandler<ListHostedDeploymentsRequest,​ListHostedDeploymentsResponse> handler)
        Lists the hosted applications in a specific compartment.

        Provide either applicationId or applicationIamId to filter by parent.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listImportedModels

        Future<ListImportedModelsResponse> listImportedModels​(ListImportedModelsRequest request,
                                                              AsyncHandler<ListImportedModelsRequest,​ListImportedModelsResponse> handler)
        Lists imported models in a specific compartment.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listModelDiscovery

        Future<ListModelDiscoveryResponse> listModelDiscovery​(ListModelDiscoveryRequest request,
                                                              AsyncHandler<ListModelDiscoveryRequest,​ListModelDiscoveryResponse> handler)
        Retrieves a list of models along with their capabilities, supported features, and deployment availability.

        Results can be filtered by attributes such as region, realm, model identifier, supported inference APIs, serving modes, and access type.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listModels

        Future<ListModelsResponse> listModels​(ListModelsRequest request,
                                              AsyncHandler<ListModelsRequest,​ListModelsResponse> handler)
        Lists the models in a specific compartment.

        Includes pretrained base models and fine-tuned custom models.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listRoutingProfiles

        Future<ListRoutingProfilesResponse> listRoutingProfiles​(ListRoutingProfilesRequest request,
                                                                AsyncHandler<ListRoutingProfilesRequest,​ListRoutingProfilesResponse> handler)
        Lists the routing profiles of a specific compartment.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listSandboxWarmPools

        Future<ListSandboxWarmPoolsResponse> listSandboxWarmPools​(ListSandboxWarmPoolsRequest request,
                                                                  AsyncHandler<ListSandboxWarmPoolsRequest,​ListSandboxWarmPoolsResponse> handler)
        Lists named MANAGED and CUSTOM pools for Sandbox-enabled Projects, including zero targets and in-progress management operations.

        Reserved defaults can be resized but cannot be created or deleted by customers. DELETED resources are excluded. Responses include CP management lifecycle but do not perform runtime reads or return ready capacity.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listSemanticStores

        Future<ListSemanticStoresResponse> listSemanticStores​(ListSemanticStoresRequest request,
                                                              AsyncHandler<ListSemanticStoresRequest,​ListSemanticStoresResponse> handler)
        Lists the SemanticStores given specific filter.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listWorkRequestErrors

        Future<ListWorkRequestErrorsResponse> listWorkRequestErrors​(ListWorkRequestErrorsRequest request,
                                                                    AsyncHandler<ListWorkRequestErrorsRequest,​ListWorkRequestErrorsResponse> handler)
        Lists the errors for a work request.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listWorkRequestLogs

        Future<ListWorkRequestLogsResponse> listWorkRequestLogs​(ListWorkRequestLogsRequest request,
                                                                AsyncHandler<ListWorkRequestLogsRequest,​ListWorkRequestLogsResponse> handler)
        Lists the logs for a work request.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • listWorkRequests

        Future<ListWorkRequestsResponse> listWorkRequests​(ListWorkRequestsRequest request,
                                                          AsyncHandler<ListWorkRequestsRequest,​ListWorkRequestsResponse> handler)
        Lists the work requests in a compartment.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • renewApiKey

        Future<RenewApiKeyResponse> renewApiKey​(RenewApiKeyRequest request,
                                                AsyncHandler<RenewApiKeyRequest,​RenewApiKeyResponse> handler)
        Renew the primary or secondary key.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • setApiKeyState

        Future<SetApiKeyStateResponse> setApiKeyState​(SetApiKeyStateRequest request,
                                                      AsyncHandler<SetApiKeyStateRequest,​SetApiKeyStateResponse> handler)
        Set state of the key.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • updateApiKey

        Future<UpdateApiKeyResponse> updateApiKey​(UpdateApiKeyRequest request,
                                                  AsyncHandler<UpdateApiKeyRequest,​UpdateApiKeyResponse> handler)
        Updates the properties of an apiKey.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • updateEndpoint

        Future<UpdateEndpointResponse> updateEndpoint​(UpdateEndpointRequest request,
                                                      AsyncHandler<UpdateEndpointRequest,​UpdateEndpointResponse> handler)
        Updates the properties of an endpoint.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • updateImportedModel

        Future<UpdateImportedModelResponse> updateImportedModel​(UpdateImportedModelRequest request,
                                                                AsyncHandler<UpdateImportedModelRequest,​UpdateImportedModelResponse> handler)
        Updates the properties of an imported model such as name, description, freeform tags, and defined tags.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • updateModel

        Future<UpdateModelResponse> updateModel​(UpdateModelRequest request,
                                                AsyncHandler<UpdateModelRequest,​UpdateModelResponse> handler)
        Updates the properties of a custom model such as name, description, version, freeform tags, and defined tags.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • updateRoutingProfile

        Future<UpdateRoutingProfileResponse> updateRoutingProfile​(UpdateRoutingProfileRequest request,
                                                                  AsyncHandler<UpdateRoutingProfileRequest,​UpdateRoutingProfileResponse> handler)
        Updates the properties of a routing profile.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • updateSandboxWarmPool

        Future<UpdateSandboxWarmPoolResponse> updateSandboxWarmPool​(UpdateSandboxWarmPoolRequest request,
                                                                    AsyncHandler<UpdateSandboxWarmPoolRequest,​UpdateSandboxWarmPoolResponse> handler)
        Only desiredCapacity may change.

        If desiredCapacity is omitted, the current desired capacity is preserved. An empty update object is allowed; an explicit null value for desiredCapacity is not allowed. Named MANAGED and CUSTOM pools and reserved MANAGED defaults can be resized. Default-pool updates use the existing Project configuration workflow; no separate desired configuration is created for those entries. CP persists UPDATING and a Work Request, applies the desired replica count, then returns the pool to ACTIVE after verifying the configuration. The workflow does not wait for ready members. Zero pauses idle prewarming. Once the pool is ACTIVE, named-pool Sandbox creation can still cold-start from its available applied template when no eligible warm member is available, regardless of the capacity target. Already-admitted Sandboxes continue. Unnamed Sandbox creation retains its existing behavior. Concurrent management operations return 409. If provided, if-match must match the current configuration ETag; otherwise this operation returns 412.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.
      • updateSemanticStore

        Future<UpdateSemanticStoreResponse> updateSemanticStore​(UpdateSemanticStoreRequest request,
                                                                AsyncHandler<UpdateSemanticStoreRequest,​UpdateSemanticStoreResponse> handler)
        Updates the properties of a SemanticStore.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.