langsmithrb 0.1.0

data/lib/langsmith/client.rb

@@ -0,0 +1,1023 @@
+# frozen_string_literal: true
+
+require "faraday"
+require "json"
+
+module Langsmith
+  class Client
+    attr_reader :api_key, :api_url
+
+    # Initialize a new LangSmith client
+    #
+    # @param api_key [String] LangSmith API key
+    # @param api_url [String] LangSmith API URL
+    def initialize(api_key: nil, api_url: nil)
+      @api_key = api_key || ENV["LANGSMITH_API_KEY"] || Langsmith.api_key
+      @api_url = api_url || ENV["LANGSMITH_API_URL"] || Langsmith.api_url || Langsmith::DEFAULT_API_URL
+      
+      raise Langsmith::Errors::AuthenticationError, "API key is required" unless @api_key
+    end
+
+    # Create a new run
+    #
+    # @param name [String] Name of the run
+    # @param run_type [String] Type of run (e.g., llm, chain, tool)
+    # @param project_name [String] Name of the project
+    # @param inputs [Hash] Input values for the run
+    # @param extra [Hash] Additional metadata for the run
+    # @return [Langsmith::Run] The created run
+    def create_run(name:, run_type:, project_name: nil, inputs: {}, extra: {})
+      data = {
+        name: name,
+        run_type: run_type,
+        inputs: inputs,
+        extra: extra
+      }
+      data[:project_name] = project_name if project_name
+
+      response = post("/runs", data)
+      Langsmith::Run.new(self, response)
+    end
+
+    # Update a run
+    #
+    # @param run_id [String] ID of the run to update
+    # @param outputs [Hash] Output values from the run
+    # @param end_time [Time] End time of the run
+    # @param error [String] Error message if the run failed
+    # @return [Langsmith::Run] The updated run
+    def update_run(run_id:, outputs: nil, end_time: nil, error: nil)
+      data = {}
+      data[:outputs] = outputs if outputs
+      data[:end_time] = end_time.iso8601 if end_time
+      data[:error] = error if error
+
+      response = patch("/runs/#{run_id}", data)
+      Langsmith::Run.new(self, response)
+    end
+
+    # Get a run by ID
+    #
+    # @param run_id [String] ID of the run to retrieve
+    # @return [Langsmith::Run] The requested run
+    def get_run(run_id:)
+      response = get("/runs/#{run_id}")
+      Langsmith::Run.new(self, response)
+    end
+
+    # List runs with optional filters
+    #
+    # @param project_name [String] Filter by project name
+    # @param run_type [String] Filter by run type
+    # @param limit [Integer] Maximum number of runs to return
+    # @return [Array<Langsmith::Run>] List of runs
+    def list_runs(project_name: nil, run_type: nil, limit: 100)
+      params = {}
+      params[:project_name] = project_name if project_name
+      params[:run_type] = run_type if run_type
+      params[:limit] = limit
+
+      response = get("/runs", params)
+      response.map { |run_data| Langsmith::Run.new(self, run_data) }
+    end
+
+    # Create a new project
+    #
+    # @param name [String] Name of the project
+    # @param description [String] Description of the project
+    # @return [Langsmith::Project] The created project
+    def create_project(name:, description: nil)
+      data = { name: name }
+      data[:description] = description if description
+
+      response = post("/projects", data)
+      Langsmith::Project.new(self, response)
+    end
+
+    # Get a project by name
+    #
+    # @param name [String] Name of the project to retrieve
+    # @return [Langsmith::Project] The requested project
+    def get_project(name:)
+      response = get("/projects/#{name}")
+      Langsmith::Project.new(self, response)
+    end
+
+    # List projects
+    #
+    # @param limit [Integer] Maximum number of projects to return
+    # @return [Array<Langsmith::Project>] List of projects
+    def list_projects(limit: 100)
+      params = { limit: limit }
+      response = get("/projects", params)
+      response.map { |project_data| Langsmith::Project.new(self, project_data) }
+    end
+
+    # Create a new dataset
+    #
+    # @param name [String] Name of the dataset
+    # @param description [String] Description of the dataset
+    # @return [Langsmith::Dataset] The created dataset
+    def create_dataset(name:, description: nil)
+      data = { name: name }
+      data[:description] = description if description
+
+      response = post("/datasets", data)
+      Langsmith::Dataset.new(self, response)
+    end
+
+    # Get a dataset by name
+    #
+    # @param name [String] Name of the dataset to retrieve
+    # @return [Langsmith::Dataset] The requested dataset
+    def get_dataset(name:)
+      response = get("/datasets/#{name}")
+      Langsmith::Dataset.new(self, response)
+    end
+
+    # List datasets
+    #
+    # @param limit [Integer] Maximum number of datasets to return
+    # @param offset [Integer] Number of datasets to skip
+    # @param name [String, nil] Filter by dataset name (optional)
+    # @param name_contains [String, nil] Filter by dataset name containing string (optional)
+    # @return [Array<Langsmith::Dataset>] List of datasets
+    def list_datasets(limit: 100, offset: 0, name: nil, name_contains: nil)
+      params = { 
+        limit: limit,
+        offset: offset
+      }
+      params[:name] = name if name
+      params[:name_contains] = name_contains if name_contains
+      
+      response = get("/datasets", params)
+      response.map { |dataset_data| Langsmith::Dataset.new(self, dataset_data) }
+    end
+    
+    # Get a dataset by ID
+    #
+    # @param id [String] ID of the dataset to retrieve
+    # @return [Langsmith::Dataset] The requested dataset
+    def get_dataset_by_id(id:)
+      response = get("/datasets/#{id}")
+      Langsmith::Dataset.new(self, response)
+    end
+    
+    # Update a dataset
+    #
+    # @param id [String] ID of the dataset to update
+    # @param name [String, nil] New name for the dataset (optional)
+    # @param description [String, nil] New description for the dataset (optional)
+    # @return [Langsmith::Dataset] The updated dataset
+    def update_dataset(id:, name: nil, description: nil)
+      data = {}
+      data[:name] = name if name
+      data[:description] = description if description
+      
+      response = patch("/datasets/#{id}", data)
+      Langsmith::Dataset.new(self, response)
+    end
+    
+    # Delete a dataset
+    #
+    # @param id [String] ID of the dataset to delete
+    # @return [Boolean] True if successful
+    def delete_dataset(id:)
+      delete("/datasets/#{id}")
+      true
+    end
+    
+    # Get an example by ID
+    #
+    # @param id [String] ID of the example to retrieve
+    # @return [Langsmith::Example] The requested example
+    def get_example(id:)
+      response = get("/examples/#{id}")
+      Langsmith::Example.new(self, response)
+    end
+    
+    # Update an example
+    #
+    # @param id [String] ID of the example to update
+    # @param inputs [Hash, nil] New input values (optional)
+    # @param outputs [Hash, nil] New output values (optional)
+    # @param metadata [Hash, nil] New metadata (optional)
+    # @return [Langsmith::Example] The updated example
+    def update_example(id:, inputs: nil, outputs: nil, metadata: nil)
+      data = {}
+      data[:inputs] = inputs if inputs
+      data[:outputs] = outputs if outputs
+      data[:metadata] = metadata if metadata
+      
+      response = patch("/examples/#{id}", data)
+      Langsmith::Example.new(self, response)
+    end
+    
+    # Delete an example
+    #
+    # @param id [String] ID of the example to delete
+    # @return [Boolean] True if successful
+    def delete_example(id:)
+      delete("/examples/#{id}")
+      true
+    end
+    
+    # Create multiple examples in batch
+    #
+    # @param dataset_id [String] ID of the dataset to add examples to
+    # @param examples [Array<Hash>] Array of example data, each containing :inputs and optionally :outputs and :metadata
+    # @return [Array<Langsmith::Example>] The created examples
+    def create_examples_batch(dataset_id:, examples:)
+      data = examples.map do |example|
+        example_data = {
+          dataset_id: dataset_id,
+          inputs: example[:inputs]
+        }
+        example_data[:outputs] = example[:outputs] if example[:outputs]
+        example_data[:metadata] = example[:metadata] if example[:metadata]
+        example_data
+      end
+      
+      response = post("/examples/batch", { examples: data })
+      response.map { |example_data| Langsmith::Example.new(self, example_data) }
+    end
+    
+    # Get an evaluation by ID
+    #
+    # @param id [String] ID of the evaluation to retrieve
+    # @return [Langsmith::Evaluation] The requested evaluation
+    def get_evaluation(id:)
+      response = get("/evaluations/#{id}")
+      Langsmith::Evaluation.new(self, response)
+    end
+    
+    # List evaluations with optional filters
+    #
+    # @param dataset_id [String, nil] Filter by dataset ID (optional)
+    # @param evaluator_name [String, nil] Filter by evaluator name (optional)
+    # @param run_id [String, nil] Filter by run ID (optional)
+    # @param status [String, nil] Filter by status (optional)
+    # @param limit [Integer] Maximum number of evaluations to return
+    # @param offset [Integer] Number of evaluations to skip
+    # @return [Array<Langsmith::Evaluation>] List of evaluations
+    def list_evaluations(dataset_id: nil, evaluator_name: nil, run_id: nil, status: nil, limit: 100, offset: 0)
+      params = {
+        limit: limit,
+        offset: offset
+      }
+      params[:dataset_id] = dataset_id if dataset_id
+      params[:evaluator_name] = evaluator_name if evaluator_name
+      params[:run_id] = run_id if run_id
+      params[:status] = status if status
+      
+      response = get("/evaluations", params)
+      response.map { |eval_data| Langsmith::Evaluation.new(self, eval_data) }
+    end
+    
+    # Update an evaluation's metadata
+    #
+    # @param id [String] ID of the evaluation to update
+    # @param metadata [Hash] New metadata for the evaluation
+    # @return [Langsmith::Evaluation] The updated evaluation
+    def update_evaluation_metadata(id:, metadata:)
+      data = { metadata: metadata }
+      response = patch("/evaluations/#{id}", data)
+      Langsmith::Evaluation.new(self, response)
+    end
+    
+    # Cancel an evaluation
+    #
+    # @param id [String] ID of the evaluation to cancel
+    # @return [Langsmith::Evaluation] The canceled evaluation
+    def cancel_evaluation(id:)
+      response = post("/evaluations/#{id}/cancel")
+      Langsmith::Evaluation.new(self, response)
+    end
+    
+    # Delete an evaluation
+    #
+    # @param id [String] ID of the evaluation to delete
+    # @return [Boolean] True if successful
+    def delete_evaluation(id:)
+      delete("/evaluations/#{id}")
+      true
+    end
+
+    # Create feedback for a run
+    #
+    # @param run_id [String] ID of the run to provide feedback for
+    # @param key [String] Feedback key (e.g., "correctness", "helpfulness")
+    # @param score [Float] Feedback score (typically 0.0 to 1.0)
+    # @param comment [String] Optional comment with the feedback
+    # @return [Langsmith::Feedback] The created feedback
+    def create_feedback(run_id:, key:, score:, comment: nil)
+      data = {
+        run_id: run_id,
+        key: key,
+        score: score
+      }
+      data[:comment] = comment if comment
+
+      response = post("/feedback", data)
+      Langsmith::Feedback.new(self, response)
+    end
+
+    # Get feedback for a run
+    #
+    # @param run_id [String] ID of the run to get feedback for
+    # @return [Array<Langsmith::Feedback>] List of feedback for the run
+    def get_feedback(run_id:)
+      params = { run_id: run_id }
+      response = get("/feedback", params)
+      response.map { |feedback_data| Langsmith::Feedback.new(self, feedback_data) }
+    end
+
+    # Create a new tracer session
+    #
+    # @param name [String] Name of the tracer session
+    # @param metadata [Hash] Additional metadata for the tracer session
+    # @return [Hash] The created tracer session data
+    def create_tracer_session(name:, metadata: {})
+      data = {
+        name: name,
+        metadata: metadata
+      }
+      post("/tracer-sessions", data)
+    end
+
+    # Get a tracer session by ID
+    #
+    # @param id [String] ID of the tracer session to retrieve
+    # @return [Hash] The requested tracer session data
+    def get_tracer_session(id:)
+      get("/tracer-sessions/#{id}")
+    end
+
+    # List tracer sessions with optional filters
+    #
+    # @param limit [Integer] Maximum number of tracer sessions to return
+    # @param offset [Integer] Number of tracer sessions to skip
+    # @return [Array<Hash>] List of tracer sessions
+    def list_tracer_sessions(limit: 100, offset: 0)
+      params = {
+        limit: limit,
+        offset: offset
+      }
+      get("/tracer-sessions", params)
+    end
+
+    # Get current organization information
+    #
+    # @return [Hash] Organization information
+    def get_current_organization
+      get("/orgs/current")
+    end
+
+    # List organizations the user belongs to
+    #
+    # @return [Array<Hash>] List of organizations
+    def list_organizations
+      get("/orgs")
+    end
+
+    # Get organization by ID
+    #
+    # @param id [String] ID of the organization to retrieve
+    # @return [Hash] The requested organization data
+    def get_organization(id:)
+      get("/orgs/#{id}")
+    end
+
+    # List API keys
+    #
+    # @return [Array<Hash>] List of API keys
+    def list_api_keys
+      get("/api-key")
+    end
+
+    # Create a new API key
+    #
+    # @param name [String] Name of the API key
+    # @param expires_at [Time, nil] Expiration time for the API key (optional)
+    # @return [Hash] The created API key data
+    def create_api_key(name:, expires_at: nil)
+      data = { name: name }
+      data[:expires_at] = expires_at.iso8601 if expires_at
+      post("/api-key", data)
+    end
+
+    # Delete an API key
+    #
+    # @param id [String] ID of the API key to delete
+    # @return [Boolean] True if successful
+    def delete_api_key(id:)
+      delete("/api-key/#{id}")
+      true
+    end
+
+    # Get tenant information
+    #
+    # @param id [String] ID of the tenant to retrieve
+    # @return [Hash] The requested tenant data
+    def get_tenant(id:)
+      get("/tenant/#{id}")
+    end
+
+    # List tenants
+    #
+    # @return [Array<Hash>] List of tenants
+    def list_tenants
+      get("/tenant")
+    end
+
+    # Create a new tenant
+    #
+    # @param name [String] Name of the tenant
+    # @param config [Hash] Configuration for the tenant
+    # @return [Hash] The created tenant data
+    def create_tenant(name:, config: {})
+      data = {
+        name: name,
+        config: config
+      }
+      post("/tenant", data)
+    end
+
+    # Update a tenant
+    #
+    # @param id [String] ID of the tenant to update
+    # @param name [String, nil] New name for the tenant (optional)
+    # @param config [Hash, nil] New configuration for the tenant (optional)
+    # @return [Hash] The updated tenant data
+    def update_tenant(id:, name: nil, config: nil)
+      data = {}
+      data[:name] = name if name
+      data[:config] = config if config
+      patch("/tenant/#{id}", data)
+    end
+
+    # Create a new tag
+    #
+    # @param name [String] Name of the tag
+    # @return [Hash] The created tag data
+    def create_tag(name:)
+      data = { name: name }
+      post("/tags", data)
+    end
+
+    # Get a tag by ID
+    #
+    # @param id [String] ID of the tag to retrieve
+    # @return [Hash] The requested tag data
+    def get_tag(id:)
+      get("/tags/#{id}")
+    end
+
+    # List tags
+    #
+    # @param limit [Integer] Maximum number of tags to return
+    # @param offset [Integer] Number of tags to skip
+    # @return [Array<Hash>] List of tags
+    def list_tags(limit: 100, offset: 0)
+      params = {
+        limit: limit,
+        offset: offset
+      }
+      get("/tags", params)
+    end
+
+    # Delete a tag
+    #
+    # @param id [String] ID of the tag to delete
+    # @return [Boolean] True if successful
+    def delete_tag(id:)
+      delete("/tags/#{id}")
+      true
+    end
+
+    # Create a new prompt
+    #
+    # @param name [String] Name of the prompt
+    # @param prompt_template [String] The prompt template
+    # @param metadata [Hash] Additional metadata for the prompt
+    # @return [Hash] The created prompt data
+    def create_prompt(name:, prompt_template:, metadata: {})
+      data = {
+        name: name,
+        prompt_template: prompt_template,
+        metadata: metadata
+      }
+      post("/prompts", data)
+    end
+
+    # Get a prompt by ID
+    #
+    # @param id [String] ID of the prompt to retrieve
+    # @return [Hash] The requested prompt data
+    def get_prompt(id:)
+      get("/prompts/#{id}")
+    end
+
+    # List prompts
+    #
+    # @param limit [Integer] Maximum number of prompts to return
+    # @param offset [Integer] Number of prompts to skip
+    # @return [Array<Hash>] List of prompts
+    def list_prompts(limit: 100, offset: 0)
+      params = {
+        limit: limit,
+        offset: offset
+      }
+      get("/prompts", params)
+    end
+
+    # Update a prompt
+    #
+    # @param id [String] ID of the prompt to update
+    # @param name [String, nil] New name for the prompt (optional)
+    # @param prompt_template [String, nil] New prompt template (optional)
+    # @param metadata [Hash, nil] New metadata for the prompt (optional)
+    # @return [Hash] The updated prompt data
+    def update_prompt(id:, name: nil, prompt_template: nil, metadata: nil)
+      data = {}
+      data[:name] = name if name
+      data[:prompt_template] = prompt_template if prompt_template
+      data[:metadata] = metadata if metadata
+      patch("/prompts/#{id}", data)
+    end
+
+    # Delete a prompt
+    #
+    # @param id [String] ID of the prompt to delete
+    # @return [Boolean] True if successful
+    def delete_prompt(id:)
+      delete("/prompts/#{id}")
+      true
+    end
+
+    # Create a new annotation queue
+    #
+    # @param name [String] Name of the annotation queue
+    # @param description [String] Description of the annotation queue
+    # @param metadata [Hash] Additional metadata for the annotation queue
+    # @return [Hash] The created annotation queue data
+    def create_annotation_queue(name:, description: nil, metadata: {})
+      data = {
+        name: name,
+        metadata: metadata
+      }
+      data[:description] = description if description
+      post("/annotation-queues", data)
+    end
+
+    # Get an annotation queue by ID
+    #
+    # @param id [String] ID of the annotation queue to retrieve
+    # @return [Hash] The requested annotation queue data
+    def get_annotation_queue(id:)
+      get("/annotation-queues/#{id}")
+    end
+
+    # List annotation queues
+    #
+    # @param limit [Integer] Maximum number of annotation queues to return
+    # @param offset [Integer] Number of annotation queues to skip
+    # @return [Array<Hash>] List of annotation queues
+    def list_annotation_queues(limit: 100, offset: 0)
+      params = {
+        limit: limit,
+        offset: offset
+      }
+      get("/annotation-queues", params)
+    end
+
+    # Update an annotation queue
+    #
+    # @param id [String] ID of the annotation queue to update
+    # @param name [String, nil] New name for the annotation queue (optional)
+    # @param description [String, nil] New description for the annotation queue (optional)
+    # @param metadata [Hash, nil] New metadata for the annotation queue (optional)
+    # @return [Hash] The updated annotation queue data
+    def update_annotation_queue(id:, name: nil, description: nil, metadata: nil)
+      data = {}
+      data[:name] = name if name
+      data[:description] = description if description
+      data[:metadata] = metadata if metadata
+      patch("/annotation-queues/#{id}", data)
+    end
+
+    # Delete an annotation queue
+    #
+    # @param id [String] ID of the annotation queue to delete
+    # @return [Boolean] True if successful
+    def delete_annotation_queue(id:)
+      delete("/annotation-queues/#{id}")
+      true
+    end
+
+    # Create a new feedback config
+    #
+    # @param name [String] Name of the feedback config
+    # @param type [String] Type of feedback config
+    # @param metadata [Hash] Additional metadata for the feedback config
+    # @return [Hash] The created feedback config data
+    def create_feedback_config(name:, type:, metadata: {})
+      data = {
+        name: name,
+        type: type,
+        metadata: metadata
+      }
+      post("/feedback-configs", data)
+    end
+
+    # Get a feedback config by ID
+    #
+    # @param id [String] ID of the feedback config to retrieve
+    # @return [Hash] The requested feedback config data
+    def get_feedback_config(id:)
+      get("/feedback-configs/#{id}")
+    end
+
+    # List feedback configs
+    #
+    # @param limit [Integer] Maximum number of feedback configs to return
+    # @param offset [Integer] Number of feedback configs to skip
+    # @return [Array<Hash>] List of feedback configs
+    def list_feedback_configs(limit: 100, offset: 0)
+      params = {
+        limit: limit,
+        offset: offset
+      }
+      get("/feedback-configs", params)
+    end
+
+    # Update a feedback config
+    #
+    # @param id [String] ID of the feedback config to update
+    # @param name [String, nil] New name for the feedback config (optional)
+    # @param type [String, nil] New type for the feedback config (optional)
+    # @param metadata [Hash, nil] New metadata for the feedback config (optional)
+    # @return [Hash] The updated feedback config data
+    def update_feedback_config(id:, name: nil, type: nil, metadata: nil)
+      data = {}
+      data[:name] = name if name
+      data[:type] = type if type
+      data[:metadata] = metadata if metadata
+      patch("/feedback-configs/#{id}", data)
+    end
+
+    # Delete a feedback config
+    #
+    # @param id [String] ID of the feedback config to delete
+    # @return [Boolean] True if successful
+    def delete_feedback_config(id:)
+      delete("/feedback-configs/#{id}")
+      true
+    end
+
+    # Get usage limits
+    #
+    # @return [Hash] Usage limits information
+    def get_usage_limits
+      get("/usage-limits")
+    end
+
+    # Get API info
+    #
+    # @return [Hash] API information
+    def get_api_info
+      get("/info")
+    end
+
+    # Get analytics for a project
+    #
+    # @param project_id [String] ID of the project to get analytics for
+    # @param start_time [Time, nil] Start time for analytics (optional)
+    # @param end_time [Time, nil] End time for analytics (optional)
+    # @param group_by [String, nil] Field to group analytics by (optional)
+    # @param metrics [Array<String>, nil] Metrics to include (optional)
+    # @param filters [Hash, nil] Filters to apply (optional)
+    # @return [Hash] Analytics data
+    def get_project_analytics(project_id:, start_time: nil, end_time: nil, group_by: nil, metrics: nil, filters: nil)
+      params = {}
+      params[:start_time] = start_time.iso8601 if start_time
+      params[:end_time] = end_time.iso8601 if end_time
+      params[:group_by] = group_by if group_by
+      params[:metrics] = metrics if metrics
+      params[:filters] = filters if filters
+      
+      get("/projects/#{project_id}/analytics", params)
+    end
+
+    # Get analytics for a dataset
+    #
+    # @param dataset_id [String] ID of the dataset to get analytics for
+    # @param start_time [Time, nil] Start time for analytics (optional)
+    # @param end_time [Time, nil] End time for analytics (optional)
+    # @param group_by [String, nil] Field to group analytics by (optional)
+    # @param metrics [Array<String>, nil] Metrics to include (optional)
+    # @param filters [Hash, nil] Filters to apply (optional)
+    # @return [Hash] Analytics data
+    def get_dataset_analytics(dataset_id:, start_time: nil, end_time: nil, group_by: nil, metrics: nil, filters: nil)
+      params = {}
+      params[:start_time] = start_time.iso8601 if start_time
+      params[:end_time] = end_time.iso8601 if end_time
+      params[:group_by] = group_by if group_by
+      params[:metrics] = metrics if metrics
+      params[:filters] = filters if filters
+      
+      get("/datasets/#{dataset_id}/analytics", params)
+    end
+
+    # Create a comment on a run
+    #
+    # @param run_id [String] ID of the run to comment on
+    # @param comment [String] Comment text
+    # @param metadata [Hash, nil] Additional metadata for the comment (optional)
+    # @return [Hash] The created comment data
+    def create_run_comment(run_id:, comment:, metadata: nil)
+      data = {
+        comment: comment
+      }
+      data[:metadata] = metadata if metadata
+      
+      post("/runs/#{run_id}/comments", data)
+    end
+
+    # List comments on a run
+    #
+    # @param run_id [String] ID of the run to list comments for
+    # @param limit [Integer] Maximum number of comments to return
+    # @param offset [Integer] Number of comments to skip
+    # @return [Array<Hash>] List of comments
+    def list_run_comments(run_id:, limit: 100, offset: 0)
+      params = {
+        limit: limit,
+        offset: offset
+      }
+      
+      get("/runs/#{run_id}/comments", params)
+    end
+
+    # Delete a comment
+    #
+    # @param comment_id [String] ID of the comment to delete
+    # @return [Boolean] True if successful
+    def delete_comment(comment_id:)
+      delete("/comments/#{comment_id}")
+      true
+    end
+
+    # Create an event
+    #
+    # @param name [String] Event name
+    # @param data [Hash] Event data
+    # @param metadata [Hash, nil] Additional metadata for the event (optional)
+    # @return [Hash] The created event data
+    def create_event(name:, data:, metadata: nil)
+      event_data = {
+        name: name,
+        data: data
+      }
+      event_data[:metadata] = metadata if metadata
+      
+      post("/events", event_data)
+    end
+
+    # List events
+    #
+    # @param name [String, nil] Filter by event name (optional)
+    # @param start_time [Time, nil] Start time for events (optional)
+    # @param end_time [Time, nil] End time for events (optional)
+    # @param limit [Integer] Maximum number of events to return
+    # @param offset [Integer] Number of events to skip
+    # @return [Array<Hash>] List of events
+    def list_events(name: nil, start_time: nil, end_time: nil, limit: 100, offset: 0)
+      params = {
+        limit: limit,
+        offset: offset
+      }
+      params[:name] = name if name
+      params[:start_time] = start_time.iso8601 if start_time
+      params[:end_time] = end_time.iso8601 if end_time
+      
+      get("/events", params)
+    end
+
+    # Get settings
+    #
+    # @return [Hash] Settings data
+    def get_settings
+      get("/settings")
+    end
+
+    # Update settings
+    #
+    # @param settings [Hash] Settings to update
+    # @return [Hash] Updated settings data
+    def update_settings(settings:)
+      patch("/settings", settings)
+    end
+
+    # Bulk tag runs
+    #
+    # @param run_ids [Array<String>] List of run IDs to tag
+    # @param tag_ids [Array<String>] List of tag IDs to apply
+    # @return [Hash] Result of the bulk operation
+    def bulk_tag_runs(run_ids:, tag_ids:)
+      data = {
+        run_ids: run_ids,
+        tag_ids: tag_ids
+      }
+      
+      post("/runs/bulk/tag", data)
+    end
+
+    # Bulk untag runs
+    #
+    # @param run_ids [Array<String>] List of run IDs to untag
+    # @param tag_ids [Array<String>] List of tag IDs to remove
+    # @return [Hash] Result of the bulk operation
+    def bulk_untag_runs(run_ids:, tag_ids:)
+      data = {
+        run_ids: run_ids,
+        tag_ids: tag_ids
+      }
+      
+      post("/runs/bulk/untag", data)
+    end
+
+    # Bulk delete runs
+    #
+    # @param run_ids [Array<String>] List of run IDs to delete
+    # @return [Hash] Result of the bulk operation
+    def bulk_delete_runs(run_ids:)
+      data = {
+        run_ids: run_ids
+      }
+      
+      post("/runs/bulk/delete", data)
+    end
+
+    # Create a webhook
+    #
+    # @param url [String] Webhook URL
+    # @param event_types [Array<String>] List of event types to subscribe to
+    # @param metadata [Hash, nil] Additional metadata for the webhook (optional)
+    # @return [Hash] The created webhook data
+    def create_webhook(url:, event_types:, metadata: nil)
+      data = {
+        url: url,
+        event_types: event_types
+      }
+      data[:metadata] = metadata if metadata
+      
+      post("/webhooks", data)
+    end
+
+    # Get a webhook by ID
+    #
+    # @param id [String] ID of the webhook to retrieve
+    # @return [Hash] The requested webhook data
+    def get_webhook(id:)
+      get("/webhooks/#{id}")
+    end
+
+    # List webhooks
+    #
+    # @param limit [Integer] Maximum number of webhooks to return
+    # @param offset [Integer] Number of webhooks to skip
+    # @return [Array<Hash>] List of webhooks
+    def list_webhooks(limit: 100, offset: 0)
+      params = {
+        limit: limit,
+        offset: offset
+      }
+      
+      get("/webhooks", params)
+    end
+
+    # Update a webhook
+    #
+    # @param id [String] ID of the webhook to update
+    # @param url [String, nil] New webhook URL (optional)
+    # @param event_types [Array<String>, nil] New list of event types (optional)
+    # @param metadata [Hash, nil] New metadata for the webhook (optional)
+    # @param active [Boolean, nil] Whether the webhook is active (optional)
+    # @return [Hash] The updated webhook data
+    def update_webhook(id:, url: nil, event_types: nil, metadata: nil, active: nil)
+      data = {}
+      data[:url] = url if url
+      data[:event_types] = event_types if event_types
+      data[:metadata] = metadata if metadata
+      data[:active] = active unless active.nil?
+      
+      patch("/webhooks/#{id}", data)
+    end
+
+    # Delete a webhook
+    #
+    # @param id [String] ID of the webhook to delete
+    # @return [Boolean] True if successful
+    def delete_webhook(id:)
+      delete("/webhooks/#{id}")
+      true
+    end
+
+    # List team members
+    #
+    # @param organization_id [String, nil] Organization ID (optional, defaults to current organization)
+    # @param limit [Integer] Maximum number of members to return
+    # @param offset [Integer] Number of members to skip
+    # @return [Array<Hash>] List of team members
+    def list_team_members(organization_id: nil, limit: 100, offset: 0)
+      params = {
+        limit: limit,
+        offset: offset
+      }
+      params[:organization_id] = organization_id if organization_id
+      
+      get("/team/members", params)
+    end
+
+    # Invite a team member
+    #
+    # @param email [String] Email of the person to invite
+    # @param role [String] Role to assign to the new member
+    # @param organization_id [String, nil] Organization ID (optional, defaults to current organization)
+    # @return [Hash] The created invitation data
+    def invite_team_member(email:, role:, organization_id: nil)
+      data = {
+        email: email,
+        role: role
+      }
+      data[:organization_id] = organization_id if organization_id
+      
+      post("/team/invite", data)
+    end
+
+    # Remove a team member
+    #
+    # @param user_id [String] ID of the user to remove
+    # @param organization_id [String, nil] Organization ID (optional, defaults to current organization)
+    # @return [Boolean] True if successful
+    def remove_team_member(user_id:, organization_id: nil)
+      data = {
+        user_id: user_id
+      }
+      data[:organization_id] = organization_id if organization_id
+      
+      post("/team/remove", data)
+      true
+    end
+
+    # HTTP request methods
+    
+    def get(path, params = {})
+      response = connection.get(path, params)
+      handle_response(response)
+    end
+
+    def post(path, data = {})
+      response = connection.post(path) do |req|
+        req.body = JSON.generate(data)
+      end
+      handle_response(response)
+    end
+
+    def patch(path, data = {})
+      response = connection.patch(path) do |req|
+        req.body = JSON.generate(data)
+      end
+      handle_response(response)
+    end
+    
+    def delete(path)
+      response = connection.delete(path)
+      handle_response(response)
+    end
+    
+    private
+
+    def connection
+      @connection ||= Faraday.new(url: @api_url) do |conn|
+        conn.headers["Authorization"] = "Bearer #{@api_key}"
+        conn.headers["Content-Type"] = "application/json"
+        conn.adapter Faraday.default_adapter
+      end
+    end
+
+    def handle_response(response)
+      case response.status
+      when 200..299
+        JSON.parse(response.body)
+      when 401
+        raise Langsmith::Errors::AuthenticationError, "Authentication failed: #{response.body}"
+      when 404
+        raise Langsmith::Errors::ResourceNotFoundError, "Resource not found: #{response.body}"
+      else
+        raise Langsmith::Errors::APIError, "API error (#{response.status}): #{response.body}"
+      end
+    end
+  end
+end