studio-engine 0.120.0 → 0.121.0

data/lib/studio/voice_capture.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+# The words on the engine's voice capture layer: the microphone chip and its
+# help dialog (studio/voice/_microphone_chip, _microphone_help), and the record
+# button (studio/voice/_recorder). Ported from Voicebox's MicrophoneHelper and
+# RecordingsHelper; the contract is docs/VOICE_CAPTURE.md.
+#
+# The chip names the microphone the page records from, so a switched-off
+# headset Chrome picked on its own is plain to see, and lets the person pick
+# another. A host passes `copy:` to either partial to change any line; its
+# keys merge over these, one level deep per section.
+module Studio
+  module VoiceCapture
+    # Where the chip remembers the pick (localStorage), unless a partial is given
+    # storage_key:. Mirrors STORAGE_KEY in app/javascript/studio/microphone.js.
+    STORAGE_KEY = "studio.microphone"
+
+    MICROPHONE_COPY = {
+      # Before the person allows the microphone the browser gives no names.
+      "prompt" => { "chip" => "Microphone: tap Record to allow",
+                    "note" => "Tap Record once and allow the microphone. Then you can pick one here." },
+      # The microphone icon says what the name is, so the name gets the whole
+      # width at 390px; a screen reader hears "aria" in full.
+      "ready" => { "chip" => "%{microphone}", "aria" => "Microphone: %{microphone}. Tap to pick another.",
+                   "note" => "Pick the microphone to record with. Your next take uses it." },
+      "denied" => { "chip" => "Microphone not allowed",
+                    "note" => "This site isn't allowed to use the microphone. Tap the icon beside the web address, " \
+                              "set Microphone to Allow, then reload this page." },
+      "unsupported" => { "chip" => "No microphone here",
+                         "note" => "This browser can't list microphones. Try Safari or Chrome." },
+      "fell_back" => "That microphone isn't connected, so I'm using %{microphone}.",
+      "empty" => "No microphones found. Plug one in and it shows up here.",
+      "in_use" => "In use",
+      # Shown only when the chip's controller failed to load.
+      "unavailable" => "Picking a microphone didn't load. Reload to try again.",
+      # The help dialog. Switching happens on the page, by device id, so the
+      # dialog never sends anyone to Chrome to switch: Chrome's settings are
+      # where the microphone is ALLOWED, and where a person checks it when a
+      # take stays silent.
+      "help" => {
+        "link" => "Help with microphones",
+        "title_chrome" => "How to change your microphone in Chrome",
+        "title_other" => "How to change your microphone",
+        "steps_chrome" => [
+          "Click the icon left of the address.",
+          "Turn Microphone on.",
+          "Make sure your microphone is allowed.",
+          "Reload the page."
+        ],
+        "other" => "Allow the microphone when your browser asks, or in its settings for this site, " \
+                   "then pick your microphone here and reload.",
+        "unnamed" => "the microphone",
+        "switched" => "Switched to %{microphone} ✓",
+        "switched_tip_chrome" => "If Chrome asks or it stays silent, here's how to check Chrome's microphone.",
+        "switched_tip_other" => "If your browser asks or it stays silent, here's how to check its microphone.",
+        "silent" => "I couldn't hear anything from %{microphone}.",
+        "silent_tip" => "Pick another microphone in the list, or check that the browser may use it:",
+        "denied" => "This site isn't allowed to use the microphone yet.",
+        "denied_tip" => "Allow it, then reload:",
+        "close" => "Close"
+      }
+    }.freeze
+
+    # The record button's words per state. Mirrors COPY in
+    # app/javascript/studio/voice_recorder.js, which fills any state a page
+    # leaves out; the partial renders the idle words so the button reads right
+    # before the controller connects.
+    RECORDER_COPY = {
+      "idle" => { "button" => "Record", "status" => "" },
+      "recording" => { "button" => "Stop", "status" => "Listening..." },
+      "unavailable" => "Recording didn't load on this page. Reload to try again."
+    }.freeze
+
+    module_function
+
+    # The copy with a host's overrides merged in: a Hash section merges key by
+    # key, anything else replaces.
+    def microphone_copy(overrides = nil)
+      merge(MICROPHONE_COPY, overrides)
+    end
+
+    def recorder_copy(overrides = nil)
+      merge(RECORDER_COPY, overrides)
+    end
+
+    def merge(base, overrides)
+      return base if overrides.nil? || overrides.empty?
+
+      overrides.to_h.each_with_object(base.dup) do |(key, value), merged|
+        key = key.to_s
+        merged[key] = merged[key].is_a?(Hash) && value.is_a?(Hash) ? merged[key].merge(value.transform_keys(&:to_s)) : value
+      end
+    end
+  end
+end

data/lib/studio/voice_transcription.rb

@@ -0,0 +1,404 @@
+# frozen_string_literal: true
+
+require "json"
+require "net/http"
+require "openssl"
+require "securerandom"
+require "stringio"
+require "uri"
+
+# Understand: one finished take (the recorder's blob and its mime type, plus the
+# speaker embedding the browser made of it) becomes {text, speaker, score}.
+#
+# The server half of the voice layer (docs/VOICE_TRANSCRIPTION.md). The capture
+# half (docs/VOICE_CAPTURE.md) hands the page a take; the page posts it here,
+# through Studio::VoiceTakesController (POST /voice/takes) or by calling
+# Studio::VoiceTranscription.hear itself.
+#
+#   heard = Studio::VoiceTranscription.hear(audio: io, mime_type: "audio/webm",
+#                                           user: current_user,
+#                                           embedding: vector, model: model_id)
+#   heard.to_h  # => {"text"=>"...", "speaker"=>"Pat Studio", "score"=>0.88,
+#               #     "identified"=>true, "check"=>"matched"}
+#
+# MOCK-FIRST, as Voicebox runs it (config/initializers/voicebox.rb, Adapters):
+# the transcriber is chosen by name, production defaults to the real one and
+# everywhere else to the mock, and a real adapter raises LiveCallAttempted
+# before it opens a socket while VOICE_NO_LIVE_CALLS is armed (always, in a test
+# environment). Ported from Voicebox's Transcription::OpenAI and
+# Transcription::Mock.
+#
+# WHO SPOKE is Studio::VoiceMatch against the SIGNED-IN USER'S OWN saved voice
+# (users.voice_embedding), compared only when both vectors came from the same
+# embedder revision. Named people without an account are a later card.
+#
+# NOTHING IS KEPT. The audio is read once, sent to the transcriber and dropped;
+# no vector or audio is logged (the engine's parameter filter masks
+# voice[embedding] and voice[audio]). Pure Ruby apart from the optional Rails
+# logger and environment, so the unit suite runs it without an app.
+module Studio
+  module VoiceTranscription
+    # A transcriber call that failed: the message carries the vendor's words.
+    class Error < StandardError; end
+
+    # The vendor answered a non-2xx; the status rides along so a caller can tell
+    # an auth failure from a model that fell over.
+    class HttpError < Error
+      attr_reader :status
+
+      def initialize(message, status:)
+        super(message)
+        @status = status
+      end
+    end
+
+    # A real transcriber chosen without its credential, or a name that is no
+    # adapter. The page shows NOT_CONFIGURED_MESSAGE; the cause is in the log.
+    class NotConfigured < Error; end
+
+    # DELIBERATELY OUTSIDE StandardError (Voicebox's Adapters::LiveCallAttempted):
+    # every caller turns a StandardError into a friendly failure, so a trap that
+    # was one would be swallowed by the code it guards and a test that reached
+    # a real vendor would pass quietly.
+    class LiveCallAttempted < Exception; end # rubocop:disable Lint/InheritException
+
+    NO_LIVE_CALLS_ENV = "VOICE_NO_LIVE_CALLS"
+    TRANSCRIBER_ENV = "STUDIO_VOICE_TRANSCRIBER"
+    API_KEY_ENV = "OPENAI_API_KEY"
+
+    # What a page shows when the app has no transcriber key. Says what is wrong
+    # without naming the variable to a visitor.
+    NOT_CONFIGURED_MESSAGE = "Voice isn't set up on this app yet, so I can't hear recordings. Type instead for now."
+
+    # The bounds on one take. The recorder stops itself at 60 seconds by default
+    # (studio/voice_recorder max_ms); a minute of opus is about half a megabyte,
+    # so 10 MB is far above any honest take and well under the vendor's 25 MB.
+    MAX_BYTES = 10 * 1024 * 1024
+    MAX_DURATION_MS = 120_000
+
+    # The audio types a take may be, as MediaRecorder names them (without the
+    # ";codecs=" parameter), and the extension the vendor reads the format from.
+    EXTENSIONS = {
+      "audio/webm" => "webm",
+      "video/webm" => "webm",
+      "audio/ogg" => "ogg",
+      "audio/mp4" => "mp4",
+      "audio/m4a" => "m4a",
+      "audio/x-m4a" => "m4a",
+      "audio/mpeg" => "mp3",
+      "audio/wav" => "wav",
+      "audio/x-wav" => "wav"
+    }.freeze
+
+    # The label a take gets when it is not the signed-in user's saved voice. The
+    # agent is told, and the message still sends (epic default).
+    SOMEONE_NEW = "Someone new"
+
+    # Why the speaker is (or is not) named, in Heard#check:
+    #   matched            the user's own voice, at or above VoiceMatch::THRESHOLD
+    #   below_threshold    compared, and the closest score fell short
+    #   no_profile         the user has no saved voice to compare with
+    #   embedder_mismatch  the take and the saved voice came from different
+    #                      embedders or revisions, so they were not compared
+    #   no_embedding       the take carried no usable speaker embedding
+    CHECKS = %w[matched below_threshold no_profile embedder_mismatch no_embedding].freeze
+
+    # Languages written in the Latin alphabet (Voicebox's RecordingPipeline).
+    LATIN_LANGUAGES = %w[en es fr de it pt nl].freeze
+    # What speech models write for silence, whole, lowercased, unpunctuated.
+    SILENCE_PHRASES = [
+      "thank you", "thanks", "thank you for watching", "thanks for watching",
+      "thank you for listening", "thanks for listening", "bye", "bye bye", "you"
+    ].freeze
+    FILLERS = %w[um umm uh uhh hmm mm mhm ah er erm].freeze
+
+    Heard = Struct.new(:text, :speaker, :score, :identified, :check, keyword_init: true) do
+      def identified? = identified
+
+      def to_h
+        { "text" => text, "speaker" => speaker, "score" => score, "identified" => identified, "check" => check }
+      end
+    end
+
+    # The real speech-to-text: OpenAI's POST /v1/audio/transcriptions, one
+    # multipart file. Ported from Voicebox's Transcription::OpenAI: the model is
+    # told the language (left to guess, a model handed near-silence answers a
+    # stock word in any language), and a failure other than auth is retried once
+    # on the fallback model from the start of the audio.
+    class OpenAI
+      ENDPOINT = "https://api.openai.com/v1/audio/transcriptions"
+      OPEN_TIMEOUT = 10
+      READ_TIMEOUT = 120
+      AUTH_FAILURES = [401, 403].freeze
+
+      attr_reader :model, :fallback_model, :language, :endpoint
+
+      def initialize(api_key: VoiceTranscription.api_key, model: Studio.voice_transcribe_model,
+                     fallback_model: Studio.voice_transcribe_fallback_model,
+                     language: Studio.voice_transcribe_language, endpoint: ENDPOINT)
+        @api_key = api_key
+        @model = model.to_s
+        @fallback_model = fallback_model.to_s.strip.empty? ? nil : fallback_model.to_s
+        @language = language.to_s.strip.empty? ? nil : language.to_s
+        @endpoint = endpoint
+      end
+
+      def configured? = !@api_key.to_s.strip.empty?
+
+      # io: the audio, at its start. Returns the transcript, stripped.
+      def transcribe(io:, filename:, content_type:)
+        raise NotConfigured, "#{API_KEY_ENV} is not set, so this app cannot transcribe voice" unless configured?
+
+        request_text(model, io, filename, content_type)
+      rescue HttpError => e
+        raise if fallback_model.nil? || fallback_model == model || AUTH_FAILURES.include?(e.status)
+
+        VoiceTranscription.log_warn("#{model} transcription failed (#{e.message}); retrying on #{fallback_model}")
+        io.rewind
+        request_text(fallback_model, io, filename, content_type)
+      end
+
+      # The multipart fields, apart from the socket so a test reads them.
+      def form_fields(model_name, io, filename, content_type)
+        fields = [
+          ["file", io, { filename: filename, content_type: content_type }],
+          ["model", model_name],
+          ["response_format", "json"]
+        ]
+        fields << ["language", language] if language
+        fields
+      end
+
+      # The request, built but not sent: a multipart body with a Content-Length
+      # (not chunked), the bearer key, JSON accepted.
+      def build_request(model_name, io, filename, content_type)
+        uri = URI.parse(endpoint)
+        boundary = "studio-voice-#{SecureRandom.hex(12)}"
+        request = Net::HTTP::Post.new(uri)
+        request["Authorization"] = "Bearer #{@api_key}"
+        request["Accept"] = "application/json"
+        request["Content-Type"] = "multipart/form-data; boundary=#{boundary}"
+        request.body = VoiceTranscription.multipart(form_fields(model_name, io, filename, content_type), boundary)
+        request
+      end
+
+      private
+
+      def request_text(model_name, io, filename, content_type)
+        perform(model_name, io, filename, content_type).fetch("text", "").to_s.strip
+      end
+
+      # The only place a socket opens, so the only place the trap sits.
+      def perform(model_name, io, filename, content_type)
+        uri = URI.parse(endpoint)
+        VoiceTranscription.guard_live_call!("OpenAI", host: uri.host)
+
+        request = build_request(model_name, io, filename, content_type)
+        response = Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == "https",
+                                                       open_timeout: OPEN_TIMEOUT, read_timeout: READ_TIMEOUT) do |http|
+          http.request(request)
+        end
+        interpret(response, model_name)
+      rescue Timeout::Error, SystemCallError, IOError, OpenSSL::SSL::SSLError, SocketError => e
+        raise HttpError.new("OpenAI #{model_name} could not be reached (#{e.class})", status: 0)
+      end
+
+      def interpret(response, model_name)
+        parsed = begin
+          JSON.parse(response.body.to_s)
+        rescue JSON::ParserError
+          {}
+        end
+        parsed = {} unless parsed.is_a?(Hash)
+        return parsed if response.is_a?(Net::HTTPSuccess)
+
+        detail = parsed.dig("error", "message") || response.body.to_s[0, 200]
+        raise HttpError.new("OpenAI #{model_name} answered HTTP #{response.code}: #{detail}", status: response.code.to_i)
+      end
+    end
+
+    # The default everywhere but production: no network, a fixed sentence. A
+    # test swaps the answer with Mock.reply = ->(**) { "..." } and resets with
+    # Mock.reset!. It records what it was handed (sizes, never the bytes).
+    class Mock
+      DEFAULT_TEXT = "This is a mock transcript of your voice."
+
+      class << self
+        attr_accessor :reply
+        attr_writer :calls
+
+        def calls = (@calls ||= [])
+
+        def reset!
+          self.reply = nil
+          self.calls = []
+        end
+      end
+
+      def configured? = true
+
+      def transcribe(io:, filename:, content_type:)
+        bytes = io.read.to_s.bytesize
+        self.class.calls << { filename: filename, content_type: content_type, bytes: bytes }
+        reply = self.class.reply
+        reply.nil? ? DEFAULT_TEXT : reply.call(filename: filename, content_type: content_type, bytes: bytes).to_s
+      end
+    end
+
+    ADAPTERS = { "openai" => OpenAI, "mock" => Mock }.freeze
+
+    module_function
+
+    # The transcriber's name: Studio.voice_transcriber when the host set one,
+    # else STUDIO_VOICE_TRANSCRIBER, else "openai" in production and "mock"
+    # everywhere else.
+    def adapter_name
+      configured = Studio.voice_transcriber.to_s.strip
+      return configured unless configured.empty?
+
+      from_env = ENV[TRANSCRIBER_ENV].to_s.strip
+      return from_env unless from_env.empty?
+
+      rails_env == "production" ? "openai" : "mock"
+    end
+
+    def transcriber(name = adapter_name)
+      klass = ADAPTERS.fetch(name.to_s) do
+        raise NotConfigured, "Studio.voice_transcriber=#{name.inspect} names no adapter; one of: #{ADAPTERS.keys.join(', ')}"
+      end
+      klass.new
+    end
+
+    # Studio.voice_openai_api_key, else OPENAI_API_KEY (Voicebox's name).
+    def api_key
+      key = Studio.voice_openai_api_key.to_s.strip
+      key.empty? ? ENV[API_KEY_ENV].to_s.strip : key
+    end
+
+    # Armed when VOICE_NO_LIVE_CALLS=1, and in any Rails test environment unless
+    # it is set to 0. A call to this machine (a stub server) is not live.
+    def live_calls_blocked?
+      flag = ENV[NO_LIVE_CALLS_ENV].to_s.strip
+      return true if flag == "1"
+      return false if flag == "0"
+
+      rails_env == "test"
+    end
+
+    def guard_live_call!(vendor, host:)
+      return unless live_calls_blocked?
+      return if %w[127.0.0.1 localhost ::1].include?(host.to_s)
+
+      raise LiveCallAttempted, "A live #{vendor} call was attempted with #{NO_LIVE_CALLS_ENV} armed. " \
+                               "Tests drive the mock transcriber (Studio.voice_transcriber = \"mock\")."
+    end
+
+    # "audio/webm;codecs=opus" -> "audio/webm"; nil for a type a take cannot be.
+    def mime_type(raw)
+      base = raw.to_s.split(";").first.to_s.strip.downcase
+      EXTENSIONS.key?(base) ? base : nil
+    end
+
+    def filename_for(mime)
+      "take.#{EXTENSIONS.fetch(mime_type(mime) || 'audio/webm')}"
+    end
+
+    # Why `text` cannot be what someone said, or nil when it can (Voicebox's
+    # RecordingPipeline.no_speech_reason): a model handed near-silence writes a
+    # stock phrase, a filler, or a word in another alphabet.
+    def no_speech_reason(text, language: Studio.voice_transcribe_language)
+      text = text.to_s.strip
+      return "the transcript was empty" if text.empty?
+      if LATIN_LANGUAGES.include?(language.to_s) && !text.match?(/\p{Latin}/)
+        return "the transcript has no #{language} letters, so the model was guessing"
+      end
+
+      words = text.scan(/[\p{L}\p{N}']+/)
+      return "the transcript has no words" if words.empty?
+      return "the transcript is a stock phrase speech models write for silence" if SILENCE_PHRASES.include?(words.join(" ").downcase)
+      return "the transcript is only a filler (#{words.first})" if words.size == 1 && FILLERS.include?(words.first.downcase)
+
+      nil
+    end
+
+    # One take, understood. audio: an IO (or String) of the take's bytes;
+    # mime_type: the recorder's mimeType; user: the signed-in user (or nil);
+    # embedding: the take's speaker vector from the browser (Array or JSON
+    # String), model: the embedder id that made it. Raises NotConfigured,
+    # HttpError, ArgumentError (a type a take cannot be); never logs the audio
+    # or the vector.
+    def hear(audio:, mime_type:, user:, embedding: nil, model: nil, transcriber: self.transcriber)
+      mime = self.mime_type(mime_type)
+      raise ArgumentError, "unsupported audio type #{mime_type.to_s[0, 60].inspect}" if mime.nil?
+
+      io = audio.is_a?(String) ? StringIO.new(audio) : audio
+      text = transcriber.transcribe(io: io, filename: filename_for(mime), content_type: mime).to_s.strip
+      speaker, score, check = who_spoke(user, embedding, model)
+      Heard.new(text: text, speaker: speaker, score: score, identified: check == "matched", check: check)
+    end
+
+    # [speaker label, score or nil, check] for one take against the user's own
+    # saved voice. Same embedder revision only: the take's model must be the
+    # app's embedder (Studio.voice_embedder) AND the one the user's voice was
+    # saved with.
+    def who_spoke(user, embedding, model)
+      embedder = Studio.voice_embedder.to_s
+      probe = embedding.nil? ? nil : Studio::VoiceMatch.parse(embedding, size: Studio::VoiceMatch.size(embedder))
+      probe = nil if probe && Studio::VoiceMatch.normalize(probe).nil?
+      return [SOMEONE_NEW, nil, "no_embedding"] if probe.nil?
+
+      saved_model = user.respond_to?(:voice_embedding_model) ? user.voice_embedding_model.to_s : ""
+      saved = user.respond_to?(:voice_embedding) ? Studio::VoiceMatch.vector(user.voice_embedding) : nil
+      return [SOMEONE_NEW, nil, "no_profile"] if saved.nil? || saved_model.empty?
+
+      app_model = Studio::VoiceMatch.model_id(embedder)
+      return [SOMEONE_NEW, nil, "embedder_mismatch"] unless model.to_s == app_model && saved_model == app_model
+
+      result = Studio::VoiceMatch.match(probe, among: [user], model: app_model)
+      return [SOMEONE_NEW, nil, "embedder_mismatch"] if result.score.nil?
+      return [SOMEONE_NEW, result.score, "below_threshold"] if result.unknown?
+
+      [speaker_name(user), result.score, "matched"]
+    end
+
+    def speaker_name(user)
+      %i[display_name name email].each do |attr|
+        next unless user.respond_to?(attr)
+
+        value = user.public_send(attr).to_s.strip
+        return value unless value.empty?
+      end
+      "You"
+    end
+
+    # A multipart/form-data body. fields: [name, value] or [name, io, {filename:, content_type:}].
+    def multipart(fields, boundary)
+      body = +"".b
+      fields.each do |name, value, file|
+        body << "--#{boundary}\r\n".b
+        if file
+          body << %(Content-Disposition: form-data; name="#{name}"; filename="#{file[:filename]}"\r\n).b
+          body << "Content-Type: #{file[:content_type]}\r\n\r\n".b
+          body << value.read.to_s.b
+        else
+          body << %(Content-Disposition: form-data; name="#{name}"\r\n\r\n).b
+          body << value.to_s.b
+        end
+        body << "\r\n".b
+      end
+      body << "--#{boundary}--\r\n".b
+      body
+    end
+
+    def rails_env
+      return nil unless defined?(::Rails) && ::Rails.respond_to?(:env)
+
+      ::Rails.env.to_s
+    end
+
+    def log_warn(message)
+      logger = defined?(::Rails) && ::Rails.respond_to?(:logger) ? ::Rails.logger : nil
+      logger&.warn("[studio][voice] #{message}")
+    end
+  end
+end

data/lib/studio.rb

@@ -47,6 +47,8 @@ require "studio/auth_labels"
 require "studio/profile_sections"
 require "studio/profile_image"
 require "studio/voice_match"
+require "studio/voice_capture"
+require "studio/voice_transcription"
 require "studio/oauth_identity"
 require "studio/google_sign_in"
 require "studio/newsletter"
@@ -576,6 +578,27 @@ module Studio
   # refuses a voice saved by any other embedder, so a page cannot pick its own.
   mattr_accessor :voice_embedder, default: "wespeaker"
 
+  # Understand (docs/VOICE_TRANSCRIPTION.md): POST /voice/takes turns a signed-in
+  # user's take into {text, speaker, score}. OFF BY DEFAULT: every take costs a
+  # speech-to-text call, so an app turns it on when a page posts takes.
+  mattr_accessor :voice_transcription, default: false
+
+  # Which transcriber answers: "openai" or "mock". nil means
+  # STUDIO_VOICE_TRANSCRIBER, else "openai" in production and "mock" elsewhere
+  # (Studio::VoiceTranscription.adapter_name). Tests never reach the vendor:
+  # VOICE_NO_LIVE_CALLS is armed in every test environment.
+  mattr_accessor :voice_transcriber, default: nil
+
+  # The OpenAI key for the real transcriber. nil reads OPENAI_API_KEY. Missing,
+  # the endpoint answers 503 with a line the page can show; nothing crashes.
+  mattr_accessor :voice_openai_api_key, default: nil
+
+  # The speech-to-text models (Voicebox's measured pair) and the language both
+  # are told to hear. A blank fallback turns the one retry off.
+  mattr_accessor :voice_transcribe_model, default: "gpt-4o-transcribe"
+  mattr_accessor :voice_transcribe_fallback_model, default: "whisper-1"
+  mattr_accessor :voice_transcribe_language, default: "en"
+
   # How long a freshly minted magic link stays live.
   mattr_accessor :magic_link_ttl, default: 15.minutes
 
@@ -1955,6 +1978,13 @@ module Studio
         delete "profile/voice", to: "studio/profiles#delete_voice"
       end
 
+      # Understand: one signed-in take in, {text, speaker, score} out
+      # (Studio::VoiceTakesController, docs/VOICE_TRANSCRIPTION.md). Drawn only
+      # for an app that turns it on, because every take is a paid vendor call.
+      if Studio.voice_transcription
+        post "voice/takes", to: "studio/voice_takes#create", as: :studio_voice_takes
+      end
+
       resources :error_logs, only: [:index, :show]
 
       # Admin

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: studio-engine
 version: !ruby/object:Gem::Version
-  version: 0.120.0
+  version: 0.121.0
 platform: ruby
 authors:
 - Alex McRitchie
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-10-30 00:00:00.000000000 Z
+date: 2026-11-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -473,6 +473,7 @@ files:
 - app/controllers/studio/session_states_controller.rb
 - app/controllers/studio/site_identities_controller.rb
 - app/controllers/studio/surveys_controller.rb
+- app/controllers/studio/voice_takes_controller.rb
 - app/controllers/style_controller.rb
 - app/controllers/theme_settings_controller.rb
 - app/helpers/studio/admin_models_table_helper.rb
@@ -507,12 +508,14 @@ files:
 - app/javascript/studio/controllers/knowledge_transcript_controller.js
 - app/javascript/studio/controllers/link_preview_card_controller.js
 - app/javascript/studio/controllers/link_sidebar_controller.js
+- app/javascript/studio/controllers/microphone_chip_controller.js
 - app/javascript/studio/controllers/modal_host_controller.js
 - app/javascript/studio/controllers/nav_collapse_controller.js
 - app/javascript/studio/controllers/style_modals_controller.js
 - app/javascript/studio/controllers/survey_controller.js
 - app/javascript/studio/controllers/toast_controller.js
 - app/javascript/studio/controllers/voice_profile_controller.js
+- app/javascript/studio/controllers/voice_recorder_controller.js
 - app/javascript/studio/cropper.js
 - app/javascript/studio/email_banner.js
 - app/javascript/studio/email_banner_scale.js
@@ -526,11 +529,14 @@ files:
 - app/javascript/studio/image_upload.js
 - app/javascript/studio/knowledge_transcript.js
 - app/javascript/studio/lazy_controllers.js
+- app/javascript/studio/level_meter.js
 - app/javascript/studio/leveling_activity.js
 - app/javascript/studio/link_preview_card.js
 - app/javascript/studio/link_sidebar.js
 - app/javascript/studio/loader.js
 - app/javascript/studio/local_path.js
+- app/javascript/studio/microphone.js
+- app/javascript/studio/microphone_chip.js
 - app/javascript/studio/modal_countdown.js
 - app/javascript/studio/modal_host.js
 - app/javascript/studio/nav_collapse.js
@@ -547,6 +553,7 @@ files:
 - app/javascript/studio/toast.js
 - app/javascript/studio/vendor/stimulus.js
 - app/javascript/studio/voice_profile.js
+- app/javascript/studio/voice_recorder.js
 - app/jobs/error_log_cleanup_job.rb
 - app/jobs/studio/email_delivery_job.rb
 - app/jobs/studio/health_report_job.rb
@@ -759,6 +766,10 @@ files:
 - app/views/studio/surveys/show.html.erb
 - app/views/studio/surveys/sign_in_required.html.erb
 - app/views/studio/surveys/thanks.html.erb
+- app/views/studio/voice/_microphone_chip.html.erb
+- app/views/studio/voice/_microphone_help.html.erb
+- app/views/studio/voice/_recorder.html.erb
+- app/views/studio/voice/_styles.html.erb
 - app/views/style/_components.html.erb
 - app/views/style/_host.html.erb
 - app/views/style/_modal_specimen.html.erb
@@ -893,7 +904,9 @@ files:
 - lib/studio/ui_primitives.rb
 - lib/studio/username_generator.rb
 - lib/studio/version.rb
+- lib/studio/voice_capture.rb
 - lib/studio/voice_match.rb
+- lib/studio/voice_transcription.rb
 - lib/tasks/studio_email.rake
 - lib/tasks/studio_knowledge.rake
 - lib/tasks/studio_node.rake