Struct PortkeyClient 

pub struct PortkeyClient { /* private fields */ }

Main Portkey API client for interacting with all Portkey services.

The PortkeyClient provides access to all Portkey API endpoints through specialized service interfaces. It handles authentication, request/response serialization, and provides a consistent async interface for all operations.

Features

• Thread-safe: Safe to use across multiple threads
• Cheap to clone: Uses Arc internally for efficient cloning
• Automatic authentication: Handles API key authentication automatically

Examples

Basic usage with environment configuration

use portkey_sdk::{PortkeyClient, Result};

let client = PortkeyClient::from_env()?;

Custom configuration with builder pattern

use portkey_sdk::{PortkeyConfig, PortkeyClient, Result};
use std::time::Duration;

let client = PortkeyConfig::builder()
    .with_api_key("your-api-key")
    .with_base_url("https://api.portkey.ai/v1")
    .with_timeout(Duration::from_secs(30))
    .build_client()?;

Multi-threaded usage

The client is cheap to clone (uses Arc internally):

use portkey_sdk::{PortkeyClient, Result};
use tokio::task;

let client = PortkeyClient::from_env()?;

let handles: Vec<_> = (0..3).map(|i| {
    let client = client.clone();
    task::spawn(async move {
        // Use client here
        Ok::<(), portkey_sdk::Error>(())
    })
}).collect();

for handle in handles {
    handle.await.unwrap()?;
}

Implementations

impl PortkeyClient

pub fn new(config: PortkeyConfig) -> Result<Self>

Creates a new Portkey API client.

pub fn builder() -> PortkeyBuilder

Creates a new configuration builder for constructing a Portkey client.

This is a convenience method that returns a PortkeyBuilder for building a custom client configuration.

Example

let client = PortkeyClient::builder()
    .with_api_key("your-api-key")
    .with_auth_method(AuthMethod::VirtualKey {
        virtual_key: "your-virtual-key".to_string(),
    })
    .with_timeout(Duration::from_secs(60))
    .build_client()?;

pub fn from_env() -> Result<Self>

Creates a new Portkey API client from environment variables.

This is a convenience method that creates a PortkeyConfig from environment variables and then creates a client from that config.

Environment Variables

• PORTKEY_API_KEY - Your Portkey API key (required)
• PORTKEY_BASE_URL - Base URL for the API (optional, defaults to https://api.portkey.ai/v1)
• PORTKEY_TIMEOUT_SECS - Request timeout in seconds (optional, defaults to 30)

Example

let client = PortkeyClient::from_env()?;

Trait Implementations

impl AssistantsService for PortkeyClient

async fn create_assistant( &self, request: CreateAssistantRequest, ) -> Result<Assistant>

Create an assistant with a model and instructions.

async fn retrieve_assistant(&self, assistant_id: &str) -> Result<Assistant>

Retrieves an assistant.

async fn modify_assistant( &self, assistant_id: &str, request: ModifyAssistantRequest, ) -> Result<Assistant>

Modifies an assistant.

async fn delete_assistant( &self, assistant_id: &str, ) -> Result<DeleteAssistantResponse>

Delete an assistant.

async fn list_assistants( &self, params: PaginationParams<'_>, ) -> Result<ListAssistantsResponse>

Returns a list of assistants.

async fn create_assistant_file( &self, assistant_id: &str, request: CreateAssistantFileRequest, ) -> Result<AssistantFile>

Create an assistant file by attaching a File to an assistant.

async fn retrieve_assistant_file( &self, assistant_id: &str, file_id: &str, ) -> Result<AssistantFile>

Retrieves an AssistantFile.

async fn delete_assistant_file( &self, assistant_id: &str, file_id: &str, ) -> Result<DeleteAssistantFileResponse>

Delete an assistant file.

async fn list_assistant_files( &self, assistant_id: &str, params: PaginationParams<'_>, ) -> Result<ListAssistantFilesResponse>

Returns a list of assistant files.

impl AudioService for PortkeyClient

async fn create_transcription( &self, file_data: Vec<u8>, file_name: &str, request: CreateTranscriptionRequest, ) -> Result<TranscriptionResponse>

Creates a transcription of an audio file.

async fn create_speech(&self, request: CreateSpeechRequest) -> Result<Vec<u8>>

Creates speech audio from text input.

async fn create_translation( &self, file_data: Vec<u8>, file_name: &str, request: CreateTranslationRequest, ) -> Result<TranslationResponse>

Translates audio to English.

impl BatchesService for PortkeyClient

async fn create_batch(&self, request: CreateBatchRequest) -> Result<Batch>

Creates and executes a batch from an uploaded file of requests.

async fn retrieve_batch(&self, batch_id: &str) -> Result<Batch>

Retrieves a batch.

async fn cancel_batch(&self, batch_id: &str) -> Result<Batch>

Cancels an in-progress batch.

async fn list_batches( &self, params: PaginationParams<'_>, ) -> Result<ListBatchesResponse>

List your organization’s batches.

impl ChatService for PortkeyClient

async fn create_chat_completion( &self, request: ChatCompletionRequest, ) -> Result<ChatCompletionResponse>

Creates a chat completion.

impl Clone for PortkeyClient

fn clone(&self) -> PortkeyClient

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl CompletionsService for PortkeyClient

async fn create_completion( &self, request: CreateCompletionRequest, ) -> Result<CompletionResponse>

Create a completion for the provided prompt and parameters.

impl Debug for PortkeyClient

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl EmbeddingsService for PortkeyClient

async fn create_embedding( &self, request: CreateEmbeddingRequest, ) -> Result<CreateEmbeddingResponse>

Creates an embedding vector representing the input text.

impl FeedbackService for PortkeyClient

async fn create_feedback( &self, request: CreateFeedbackRequest, ) -> Result<FeedbackResponse>

Creates feedback for a trace.

async fn update_feedback( &self, feedback_id: &str, request: UpdateFeedbackRequest, ) -> Result<FeedbackResponse>

Updates existing feedback by ID.

impl FilesService for PortkeyClient

async fn upload_file(&self, request: UploadFileRequest) -> Result<FileObject>

Upload a file that can be used across various endpoints.

async fn list_files(&self) -> Result<ListFilesResponse>

Returns a list of files that belong to the user’s organization.

async fn retrieve_file(&self, file_id: &str) -> Result<FileObject>

Returns information about a specific file.

async fn retrieve_file_content(&self, file_id: &str) -> Result<Vec<u8>>

Returns the contents of the specified file.

async fn delete_file(&self, file_id: &str) -> Result<DeleteFileResponse>

Delete a file.

impl FineTuningService for PortkeyClient

async fn create_fine_tuning_job( &self, request: CreateFineTuningJobRequest, ) -> Result<FineTuningJob>

Creates a fine-tuning job which begins the process of creating a new model from a given dataset.

async fn list_fine_tuning_jobs( &self, params: PaginationParams<'_>, ) -> Result<ListFineTuningJobsResponse>

List your organization’s fine-tuning jobs.

async fn retrieve_fine_tuning_job( &self, fine_tuning_job_id: &str, ) -> Result<FineTuningJob>

Get info about a fine-tuning job.

async fn cancel_fine_tuning_job( &self, fine_tuning_job_id: &str, ) -> Result<FineTuningJob>

Immediately cancel a fine-tuning job.

async fn list_fine_tuning_job_events( &self, fine_tuning_job_id: &str, params: PaginationParams<'_>, ) -> Result<ListFineTuningJobEventsResponse>

Get status updates for a fine-tuning job.

async fn list_fine_tuning_job_checkpoints( &self, fine_tuning_job_id: &str, params: PaginationParams<'_>, ) -> Result<ListFineTuningJobCheckpointsResponse>

List checkpoints for a fine-tuning job.

impl ImagesService for PortkeyClient

async fn generate_image( &self, request: CreateImageRequest, ) -> Result<ImagesResponse>

Generates images based on a text prompt.

async fn edit_image( &self, image_data: Vec<u8>, image_name: &str, mask_data: Option<Vec<u8>>, mask_name: Option<&str>, request: CreateImageEditRequest, ) -> Result<ImagesResponse>

Edits an image based on a prompt.

async fn create_image_variation( &self, image_data: Vec<u8>, image_name: &str, request: CreateImageVariationRequest, ) -> Result<ImagesResponse>

Creates a variation of an image.

impl LogsService for PortkeyClient

async fn create_log_export( &self, request: CreateLogExportRequest, ) -> Result<CreateLogExportResponse>

Creates a new log export.

async fn get_log_export(&self, export_id: &str) -> Result<LogExport>

Retrieves a log export by ID.

async fn start_log_export(&self, export_id: &str) -> Result<ExportTaskResponse>

Starts processing a log export.

async fn cancel_log_export(&self, export_id: &str) -> Result<ExportTaskResponse>

Cancels a running log export.

async fn download_log_export( &self, export_id: &str, ) -> Result<DownloadLogExportResponse>

Downloads a completed log export.

async fn insert_log( &self, request: InsertLogRequest, ) -> Result<InsertLogResponse>

Inserts one or more custom logs.

async fn update_log_export( &self, export_id: &str, request: UpdateLogExportRequest, ) -> Result<UpdateLogExportResponse>

Updates an existing log export.

async fn list_log_exports( &self, params: Option<ListLogExportsParams>, ) -> Result<ListLogExportsResponse>

Lists all log exports with optional workspace filter.

impl MessagesService for PortkeyClient

async fn create_message( &self, thread_id: &str, request: CreateMessageRequest, ) -> Result<Message>

Create a message.

async fn retrieve_message( &self, thread_id: &str, message_id: &str, ) -> Result<Message>

Retrieve a message.

async fn modify_message( &self, thread_id: &str, message_id: &str, request: ModifyMessageRequest, ) -> Result<Message>

Modifies a message.

async fn list_messages( &self, thread_id: &str, params: PaginationParams<'_>, ) -> Result<ListMessagesResponse>

Returns a list of messages for a given thread.

async fn retrieve_message_file( &self, thread_id: &str, message_id: &str, file_id: &str, ) -> Result<MessageFile>

Retrieves a message file.

async fn list_message_files( &self, thread_id: &str, message_id: &str, params: PaginationParams<'_>, ) -> Result<ListMessageFilesResponse>

Returns a list of message files.

impl ModelsService for PortkeyClient

async fn list_models( &self, params: Option<ListModelsParams>, ) -> Result<ListModelsResponse>

Lists the currently available models.

impl ModerationsService for PortkeyClient

async fn create_moderation( &self, request: CreateModerationRequest, ) -> Result<ModerationResponse>

Classifies if text is potentially harmful.

impl PromptsService for PortkeyClient

async fn execute_prompt( &self, prompt_id: &str, request: PromptCompletionRequest, ) -> Result<PromptCompletionResponse>

Executes a saved prompt template with the given variables and parameters.

async fn render_prompt( &self, prompt_id: &str, request: PromptRenderRequest, ) -> Result<PromptRenderResponse>

Renders a prompt template with variables and hyperparameters without executing it.

impl ResponsesService for PortkeyClient

async fn create_response( &self, request: CreateResponseRequest, ) -> Result<Response>

Creates a new response.

async fn get_response(&self, response_id: &str) -> Result<Response>

Retrieves a specific response by ID.

async fn delete_response(&self, response_id: &str) -> Result<()>

Deletes a response.

async fn list_input_items( &self, response_id: &str, params: ListInputItemsParams, ) -> Result<ListInputItemsResponse>

Lists input items for a specific response.

impl RunsService for PortkeyClient

async fn create_run( &self, thread_id: &str, request: CreateRunRequest, ) -> Result<Run>

Create a run.

async fn retrieve_run(&self, thread_id: &str, run_id: &str) -> Result<Run>

Retrieves a run.

async fn modify_run( &self, thread_id: &str, run_id: &str, request: ModifyRunRequest, ) -> Result<Run>

Modifies a run.

async fn list_runs( &self, thread_id: &str, params: PaginationParams<'_>, ) -> Result<ListRunsResponse>

Returns a list of runs belonging to a thread.

async fn submit_tool_outputs( &self, thread_id: &str, run_id: &str, request: SubmitToolOutputsRequest, ) -> Result<Run>

When a run has the status: “requires_action” and required_action.type is submit_tool_outputs, this endpoint can be used to submit the outputs from the tool calls once they’re all completed.

async fn cancel_run(&self, thread_id: &str, run_id: &str) -> Result<Run>

Cancels a run that is in_progress.

async fn create_thread_and_run(&self, request: CreateRunRequest) -> Result<Run>

Create a thread and run it in one request.

async fn retrieve_run_step( &self, thread_id: &str, run_id: &str, step_id: &str, ) -> Result<RunStep>

Retrieves a run step.

async fn list_run_steps( &self, thread_id: &str, run_id: &str, params: PaginationParams<'_>, ) -> Result<ListRunStepsResponse>

Returns a list of run steps belonging to a run.

impl ThreadsService for PortkeyClient

async fn create_thread(&self, request: CreateThreadRequest) -> Result<Thread>

Create a thread.

async fn retrieve_thread(&self, thread_id: &str) -> Result<Thread>

Retrieves a thread.

async fn modify_thread( &self, thread_id: &str, request: ModifyThreadRequest, ) -> Result<Thread>

Modifies a thread.

async fn delete_thread(&self, thread_id: &str) -> Result<DeleteThreadResponse>

Delete a thread.