Audio input, app layout tweaks, better background startup, use ExtendedTask

DESCRIPTION

@@ -22,6 +22,7 @@ Depends:
     R (>= 4.0)
 Imports: 
     assertthat,
+    bsicons,
     bslib (>= 0.6.0),
     cli,
     colorspace,
@@ -35,6 +36,7 @@ Imports:
     ids,
     jsonlite,
     magrittr,
+    promises,
     purrr,
     R6,
     rlang,
@@ -45,7 +47,6 @@ Imports:
     SSEparser,
     stringr (>= 1.5.0),
     utils,
-    waiter,
     yaml
 Suggests: 
     AzureRMR,

NAMESPACE

@@ -48,11 +48,13 @@ export(gptstudio_comment_code)
 export(gptstudio_create_skeleton)
 export(gptstudio_request_perform)
 export(gptstudio_response_process)
+export(gptstudio_run_chat_app)
 export(gptstudio_sitrep)
 export(gptstudio_skeleton_build)
 export(gptstudio_spelling_grammar)
+export(input_audio_clip)
 export(openai_create_chat_completion)
-export(run_chatgpt_app)
+export(transcribe_audio)
 import(cli)
 import(htmltools)
 import(htmlwidgets)
@@ -65,5 +67,11 @@ importFrom(assertthat,is.count)
 importFrom(assertthat,is.number)
 importFrom(assertthat,is.string)
 importFrom(glue,glue)
+importFrom(htmltools,div)
+importFrom(htmltools,htmlDependency)
+importFrom(htmltools,tag)
+importFrom(htmltools,tagList)
+importFrom(htmltools,tags)
 importFrom(jsonlite,fromJSON)
 importFrom(magrittr,"%>%")
+importFrom(shiny,icon)

NEWS.md

@@ -4,6 +4,11 @@
 - Added claude-3.5-sonnet model from Anthropic.
 - Set gpt-4o-mini as default model for OpenAI. #219
 - Fixed bugs with Azure OpenAI service. #223
+- Add audio input option for chat app. #224
+- Fix bug with chat app not loading on linux. #224
+- Allow chat app to run in Positron (not yet as background job) #224
+- API calls now run async with ExtendedTask. #224
+- New styling of chat app. #224
 
 ## gptstudio 0.4.0
 

R/addin_chatgpt.R

@@ -1,147 +1,85 @@
-#' Run Chat GPT
-#' Run the Chat GPT Shiny App as a background job and show it in the viewer pane
+#' Run GPTStudio Chat App
 #'
-#' @export
+#' This function initializes and runs the Chat GPT Shiny App as a background job
+#' in RStudio and opens it in the viewer pane or browser window.
+#'
+#' @param host A character string specifying the host on which to run the app.
+#'   Defaults to the value of `getOption("shiny.host", "127.0.0.1")`.
+#'
+#' @return This function does not return a value. It runs the Shiny app as a side effect.
+#'
+#' @details
+#' The function performs the following steps:
+#' 1. Verifies that RStudio API is available.
+#' 2. Finds an available port for the Shiny app.
+#' 3. Creates a temporary directory for the app files.
+#' 4. Runs the app as a background job in RStudio.
+#' 5. Opens the app in the RStudio viewer pane or browser window.
 #'
-#' @return This function has no return value.
+#' @note This function is designed to work within the RStudio IDE and requires
+#'   the rstudioapi package.
 #'
-#' @inheritParams shiny::runApp
 #' @export
+#'
 #' @examples
-#' # Call the function as an RStudio addin
 #' \dontrun{
 #' gptstudio_chat()
 #' }
 gptstudio_chat <- function(host = getOption("shiny.host", "127.0.0.1")) {
   rstudioapi::verifyAvailable()
-  stopifnot(rstudioapi::hasFun("viewer"))
-
-  port <- random_port()
-  app_dir <- create_tmp_app_dir()
 
-  run_app_as_bg_job(appDir = app_dir, job_name = "gptstudio", host, port)
+  port <- find_available_port()
+  app_dir <- create_temp_app_dir()
 
-  open_bg_shinyapp(host, port)
+  run_app_background(app_dir, "gptstudio", host, port)
+  open_app_in_viewer(host, port)
 }
 
+# Helper functions
 
-#' Generate a random safe port number
-#'
-#' This function generates a random port allowed by shiny::runApp.
-#'
-#' @return A single integer representing the randomly selected safe port number.
-random_port <- function() {
-  all_ports <- 3000:8000
-  unsafe_ports <- c(3659, 4045, 5060, 5061, 6000, 6566, 6665:6669, 6697)
-  safe_ports <- setdiff(all_ports, unsafe_ports)
-  sample(safe_ports, size = 1)
+find_available_port <- function() {
+  safe_ports <- setdiff(3000:8000, c(3659, 4045, 5060, 5061, 6000, 6566, 6665:6669, 6697))
+  sample(safe_ports, 1)
 }
 
-
-#' Run an R Shiny app in the background
-#'
-#' This function runs an R Shiny app as a background job using the specified
-#' directory, name, host, and port.
-#'
-#' @param job_name The name of the background job to be created
-#' @inheritParams shiny::runApp
-#' @return This function returns nothing because is meant to run an app as a
-#'   side effect.
-run_app_as_bg_job <- function(appDir = ".", job_name, host, port) { # nolint
-  job_script <- create_tmp_job_script(
-    appDir = appDir,
-    port = port,
-    host = host
-  )
-  rstudioapi::jobRunScript(job_script, name = job_name)
-  cli_alert_success(
-    glue("{job_name} initialized as background job in RStudio")
-  )
+create_temp_app_dir <- function() {
+  dir <- normalizePath(tempdir(), winslash = "/")
+  app_file <- create_temp_app_file()
+  file.copy(app_file, file.path(dir, "app.R"), overwrite = TRUE)
+  dir
 }
 
+create_temp_app_file <- function() {
+  temp_file <- tempfile(fileext = ".R")
+  ide_colors <- dput(get_ide_theme_info())
 
-#' Create a temporary job script
-#'
-#' This function creates a temporary R script file that runs the Shiny
-#' application from the specified directory with the specified port and host.
-#' @inheritParams shiny::runApp
-#' @return A string containing the path of a temporary job script
-create_tmp_job_script <- function(appDir, port, host) { # nolint
-  script_file <- tempfile(fileext = ".R")
-
-  line <-
-    glue::glue(
-      "shiny::runApp(appDir = '{appDir}', port = {port}, host = '{host}')"
-    )
+  writeLines(c(
+    glue::glue("ide_colors <- {paste(deparse(ide_colors), collapse = '\n')}"),
+    "ui <- gptstudio:::mod_app_ui('app', ide_colors)",
+    "server <- function(input, output, session) {",
+    "  gptstudio:::mod_app_server('app', ide_colors)",
+    "}",
+    "shiny::shinyApp(ui, server)"
+  ), temp_file)
 
-  file_con <- file(script_file)
-  writeLines(line, con = script_file)
-  close(file_con)
-  return(script_file)
+  temp_file
 }
 
-create_tmp_app_dir <- function() {
-  dir <- tempdir()
+run_app_background <- function(app_dir, job_name, host, port) {
+  job_script <- tempfile(fileext = ".R")
+  writeLines(glue::glue(
+    "shiny::runApp(appDir = '{app_dir}', port = {port}, host = '{host}')"
+  ), job_script)
 
-  if (.Platform$OS.type == "windows") {
-    dir <- gsub(pattern = "[\\]", replacement = "/", x = dir)
-  }
-
-  app_file <- create_tmp_app_file()
-  file.copy(from = app_file, to = file.path(dir, "app.R"), overwrite = TRUE)
-  return(dir)
-}
-
-create_tmp_app_file <- function() {
-  script_file <- tempfile(fileext = ".R")
-  ide_theme <- get_ide_theme_info() %>%
-    dput() %>%
-    utils::capture.output()
-
-  line_theme <- glue::glue(
-    "ide_colors <- {ide_theme}"
-  )
-  line_ui <- glue::glue(
-    "ui <- gptstudio:::mod_app_ui('app', ide_colors)"
-  )
-  line_server <- glue::glue(
-    "server <- function(input, output, session) {
-      gptstudio:::mod_app_server('app', ide_colors)
-    }",
-    .open = "{{",
-    .close = "}}"
-  )
-  line_run_app <- glue::glue("shiny::shinyApp(ui, server)")
-
-  file_con <- file(script_file)
-
-  writeLines(
-    text = c(line_theme, line_ui, line_server, line_run_app),
-    sep = "\n\n",
-    con = script_file
-  )
-
-  close(file_con)
-  return(script_file)
+  rstudioapi::jobRunScript(job_script, name = job_name)
+  cli::cli_alert_success("{job_name} initialized as background job in RStudio")
 }
 
-
-#' Open browser to local Shiny app
-#'
-#' This function takes in the host and port of a local Shiny app and opens the
-#' app in the default browser.
-#'
-#' @param host A character string representing the IP address or domain name of
-#'   the server where the Shiny app is hosted.
-#' @param port An integer representing the port number on which the Shiny app is
-#'   hosted.
-#'
-#' @return None (opens the Shiny app in the viewer pane or browser window)
-open_bg_shinyapp <- function(host, port) {
+open_app_in_viewer <- function(host, port) {
   url <- glue::glue("http://{host}:{port}")
   translated_url <- rstudioapi::translateLocalUrl(url, absolute = TRUE)
 
-  if (host %in% c("127.0.0.1")) {
+  if (host == "127.0.0.1") {
     cli::cli_inform(c(
       "i" = "Showing app in 'Viewer' pane",
       "i" = "Run {.run rstudioapi::viewer(\"{url}\")} to see it"
@@ -151,16 +89,19 @@ open_bg_shinyapp <- function(host, port) {
   }
 
   if (.Platform$OS.type == "unix") {
-    wait_for_bg_shinyapp(translated_url)
+    wait_for_bg_app(translated_url)
+    Sys.sleep(1)
   }
 
   rstudioapi::viewer(translated_url)
 }
 
-# This function makes a request for the app's url and fails
-# if doesn't find anything after 10 seconds
-wait_for_bg_shinyapp <- function(url) {
+wait_for_bg_app <- function(url, max_seconds = 10) {
   request(url) %>%
-    req_retry(max_seconds = 10, backoff = function(n) 0.2) %>%
+    req_retry(
+      max_seconds = max_seconds,
+      is_transient = \(resp) resp_status(resp) >= 300,
+      backoff = function(n) 0.2
+    ) %>%
     req_perform()
 }

R/addin_comment-code.R

@@ -12,7 +12,6 @@
 #' gptstudio_comment_code()
 #' }
 gptstudio_comment_code <- function() {
-
   file_ext <- get_file_extension()
 
   task <- glue::glue(

R/api-transcribe-audio.R

@@ -0,0 +1,83 @@
+#' Parse a Data URI
+#'
+#' This function parses a data URI and returns the MIME type and decoded data.
+#'
+#' @param data_uri A string. The data URI to parse.
+#'
+#' @return A list with two elements: 'mime_type' and 'data'.
+#'
+parse_data_uri <- function(data_uri) {
+  if (is.null(data_uri) || !is.character(data_uri) || length(data_uri) != 1) {
+    cli::cli_abort("Invalid input: data_uri must be a single character string")
+  }
+
+  match <- regexec("^data:(.+);base64,(.*)$", data_uri)
+  if (match[[1]][1] == -1) {
+    cli::cli_abort("Invalid data URI format")
+  }
+  groups <- regmatches(data_uri, match)[[1]]
+  mime_type <- groups[2]
+  b64data <- groups[3]
+  # Add padding if necessary
+  padding <- nchar(b64data) %% 4
+  if (padding > 0) {
+    b64data <- paste0(b64data, strrep("=", 4 - padding))
+  }
+  list(mime_type = mime_type, data = jsonlite::base64_dec(b64data))
+}
+
+#' Transcribe Audio from Data URI Using OpenAI's Whisper Model
+#'
+#' This function takes an audio file in data URI format, converts it to WAV, and
+#' sends it to OpenAI's transcription API to get the transcribed text.
+#'
+#' @param audio_input A string. The audio data in data URI format.
+#' @param api_key A string. Your OpenAI API key. Defaults to the OPENAI_API_KEY
+#'   environment variable.
+#'
+#' @return A string containing the transcribed text.
+#'
+#' @export
+#'
+#' @examples
+#' \dontrun{
+#' audio_uri <- "data:audio/webm;base64,SGVsbG8gV29ybGQ=" # Example data URI
+#' transcription <- transcribe_audio(audio_uri)
+#' print(transcription)
+#' }
+#'
+transcribe_audio <- function(audio_input, api_key = Sys.getenv("OPENAI_API_KEY")) {
+  parsed <- parse_data_uri(audio_input)
+
+  temp_webm <- tempfile(fileext = ".webm")
+  temp_wav <- tempfile(fileext = ".wav")
+  writeBin(parsed$data, temp_webm)
+  system_result <- #nolint
+    system2("ffmpeg",
+      args = c("-i", temp_webm, "-acodec", "pcm_s16le", "-ar", "44100", temp_wav), # nolint
+      stdout = TRUE,
+      stderr = TRUE
+    )
+
+  if (!file.exists(temp_wav)) {
+    cli::cli_abort("Failed to convert audio: {system_result}")
+  }
+
+  req <- request("https://api.openai.com/v1/audio/transcriptions") %>%
+    req_auth_bearer_token(api_key) %>%
+    req_body_multipart(
+      file = curl::form_file(temp_wav),
+      model = "whisper-1",
+      response_format = "text"
+    )
+
+  resp <- req_perform(req)
+
+  if (resp_is_error(resp)) {
+    cli::cli_abort("API request failed: {resp_status_desc(resp)}")
+  }
+
+  user_prompt <- resp_body_string(resp)
+  file.remove(temp_webm, temp_wav)
+  invisible(user_prompt)
+}