@lovelace_lol/polymer 0.0.1

package/src/polymer/transcription/planner.cljs

@@ -0,0 +1,203 @@
+(ns polymer.transcription.planner
+  (:require [polymer.transcription.domain :as domain]
+            [polymer.transcription.state :as state]))
+
+;; The planner turns recognition commands and provider callbacks into explicit
+;; actions. Provider APIs are not called here; the scheduler passes accepted
+;; provider work to the agency's private effector.
+
+(def supported-command-types
+  #{"configure"
+    "start"
+    "stop"
+    "cancel"
+    "reset"
+    "providerStarted"
+    "providerEnded"
+    "providerPartial"
+    "partialTranscript"
+    "providerFinal"
+    "finalTranscript"
+    "providerError"
+    "providerAudioInterruption"
+    "tts.status"
+    "ttsSpeechStarted"
+    "ttsSpeechStopped"
+    "ttsSpeechEnded"
+    "agentSpeechPrepared"
+    "agentSpeechObserved"
+    "agentSpeechWord"
+    "agentSpeechEnded"})
+
+(defn confidence
+  [command]
+  (state/clamp 0 1 (state/number-or (:confidence command) 1)))
+
+(defn allowed-confidence?
+  [command current-state]
+  (>= (confidence command) (get-in current-state [:config :minConfidence])))
+
+(defn retry-available?
+  [current-state]
+  (< (:retryCount current-state) (get-in current-state [:config :maxRetries])))
+
+(defn failure-step
+  [command current-state]
+  (cond
+    (not (contains? supported-command-types (:type command)))
+    {:op "fail" :reason "unsupported-command" :commandType (:type command)}
+
+    (and (#{"providerPartial" "partialTranscript" "providerFinal" "finalTranscript"} (:type command))
+         (not (domain/transcript-text command)))
+    {:op "ignore" :reason "empty-transcript" :commandType (:type command)}
+
+    (and (#{"providerPartial" "partialTranscript" "providerFinal" "finalTranscript"} (:type command))
+         (not (allowed-confidence? command current-state)))
+    {:op "ignore" :reason "low-confidence" :commandType (:type command)}
+
+    (and (get-in current-state [:config :agentFilteringEnabled])
+         (:agentSpeaking current-state)
+         (#{"providerPartial" "partialTranscript" "providerFinal" "finalTranscript"} (:type command))
+         (or (domain/agent-source? command)
+             (domain/agent-echo? command current-state)))
+    {:op "ignore" :reason "agent-speech" :commandType (:type command)}))
+
+(def provider-callback-types
+  #{"providerStarted" "providerEnded" "providerPartial" "providerFinal" "providerError"})
+
+(defn stale-provider-callback?
+  [command current-state]
+  (and (contains? provider-callback-types (:type command))
+       (:sessionId command)
+       (or (not (:active current-state))
+           (not= (:sessionId command) (:sessionId current-state)))))
+
+(defn tts-status-fact
+  [command now-ms]
+  (let [status (or (:status command)
+                   (:stateStatus command)
+                   (get-in command [:state :status])
+                   (case (:type command)
+                     "ttsSpeechStarted" "speaking"
+                     ("ttsSpeechStopped" "ttsSpeechEnded") "idle"
+                     "idle"))]
+    {:type "transcription.ttsStatus"
+     :agency "transcription"
+     :sourceAgency "tts"
+     :status status
+     :speaking (or (:speaking command)
+                   (= "speaking" status)
+                   (= "ttsSpeechStarted" (:type command)))
+     :phrase (or (:phrase command) (:text command))
+     :words (:words command)
+     :ttsEventType (:type command)
+     :at now-ms}))
+
+(defn command-steps
+  [command current-state now-ms]
+  (if (stale-provider-callback? command current-state)
+    [{:op "ignore"
+      :reason "stale-provider-callback"
+      :commandType (:type command)}]
+    (if-let [failure (failure-step command current-state)]
+    [failure]
+    (case (:type command)
+      "configure" [{:op "apply-config"}
+                   {:op "configure-provider"}
+                   {:op "publish-status" :status (:status current-state)}]
+      "start" (if (:active current-state)
+                [{:op "ignore" :reason "already-active" :commandType "start"}]
+                [{:op "start-session"}
+                 {:op "request-provider-start"}])
+      ("stop" "cancel") [{:op "request-provider-stop"
+                          :method (if (= "cancel" (:type command)) "abort" "stop")
+                          :reason (or (:reason command) (:type command))}
+                         {:op "stop-session"
+                          :reason (or (:reason command) (:type command))}]
+      "reset" [{:op "request-provider-stop"
+                :method "abort"
+                :reason "reset"}
+               {:op "reset-state"}]
+      "providerStarted" [{:op "record-provider-started"}]
+      "providerEnded" (if (= "retrying" (:status current-state))
+                        [{:op "ignore"
+                          :reason "provider-ended-during-retry"
+                          :commandType "providerEnded"}]
+                        [{:op "stop-session" :reason "provider-ended"}])
+      ("providerPartial" "partialTranscript")
+      (let [interrupt? (and (:agentSpeaking current-state)
+                            (get-in current-state [:config :interruptDetectionEnabled])
+                            (not (domain/agent-source? command)))]
+        (cond-> []
+          interrupt?
+          (conj {:op "publish-interruption"
+                 :text (domain/transcript-text command)
+                 :confidence (confidence command)
+                 :source (or (:source command) "provider")})
+
+          true
+          (conj {:op "publish-partial"
+                 :text (domain/transcript-text command)
+                 :confidence (confidence command)
+                 :source (or (:source command) "provider")})))
+      ("providerFinal" "finalTranscript")
+      (let [interrupt? (and (:agentSpeaking current-state)
+                            (get-in current-state [:config :interruptDetectionEnabled])
+                            (not (domain/agent-source? command)))]
+        (cond-> []
+          interrupt?
+          (conj {:op "publish-interruption"
+                 :text (domain/transcript-text command)
+                 :confidence (confidence command)
+                 :source (or (:source command) "provider")})
+
+          true
+          (conj {:op "publish-final"
+                 :text (domain/transcript-text command)
+                 :confidence (confidence command)
+                 :source (or (:source command) "provider")})))
+      "providerError"
+      (let [message (or (:message command) (:error command) "provider-error")
+            retry? (and (:active current-state)
+                        (:continuous (:config current-state))
+                        (retry-available? current-state))]
+        (cond-> [{:op "record-error"
+                  :message message
+                  :retry retry?}]
+          retry? (conj {:op "request-provider-retry"
+                        :message message
+                        :retryAfterMs (get-in current-state [:config :retryDelayMs])})
+          (not retry?) (conj {:op "stop-session"
+                              :reason "provider-error"})))
+      "providerAudioInterruption"
+      [{:op "publish-audio-interruption"
+        :timestamp (:timestamp command)
+        :microphoneLevel (:microphoneLevel command)
+        :referenceLevel (:referenceLevel command)
+        :requiredLevel (:requiredLevel command)}]
+      ("tts.status" "ttsSpeechStarted" "ttsSpeechStopped" "ttsSpeechEnded")
+      [{:op "record-tts-status"
+        :fact (tts-status-fact command now-ms)}]
+      "agentSpeechPrepared" [{:op "prepare-agent-speech"
+                              :text (:text command)
+                              :append false}]
+      "agentSpeechObserved" [{:op "prepare-agent-speech"
+                              :text (:text command)
+                              :append true}]
+      "agentSpeechWord" [{:op "record-agent-word"
+                          :word (:word command)}]
+      "agentSpeechEnded" [{:op "record-tts-status"
+                           :fact (tts-status-fact
+                                  {:type "ttsSpeechEnded"
+                                   :status "idle"
+                                   :speaking false}
+                                  now-ms)}]))))
+
+(defn plan-command
+  [command current-state now-ms]
+  (let [steps (command-steps command current-state now-ms)]
+    {:agency "transcription"
+     :commandType (:type command)
+     :createdAt now-ms
+     :ok (not (#{"fail"} (:op (first steps))))
+     :steps steps}))

package/src/polymer/transcription/scheduler.cljs

@@ -0,0 +1,225 @@
+(ns polymer.transcription.scheduler
+  (:require [polymer.transcription.state :as state]))
+
+;; The scheduler owns ordering for provider lifecycle and transcript facts. It
+;; executes accepted steps immediately, invokes the private provider effector,
+;; and preserves lifecycle request events as observable diagnostics.
+
+(defn now-ms
+  []
+  (.now js/Date))
+
+(defn queue-entry
+  [step index plan]
+  (assoc step
+         :agency "transcription"
+         :queueIndex index
+         :commandType (:commandType plan)
+         :queuedAt (now-ms)))
+
+(defn provider-request
+  [state-atom action extra]
+  (merge {:type "transcription.requestProvider"
+          :agency "transcription"
+          :targetAgency "transcription-provider"
+          :action action
+          :provider (get-in @state-atom [:config :provider])
+          :sessionId (:sessionId @state-atom)}
+         extra))
+
+(defn transcript-fact
+  [state-atom kind step now]
+  {:type (str "transcription." kind)
+   :agency "transcription"
+   :targetAgency "conversation"
+   :text (:text step)
+   :confidence (:confidence step)
+   :isFinal (= kind "final")
+   :sequence (state/next-sequence @state-atom)
+   :source (:source step)
+   :sessionId (:sessionId @state-atom)
+   :at now})
+
+(defn emit-status!
+  [emit-event state-atom status reason]
+  (emit-event (cond-> {:type "transcription.status"
+                       :agency "transcription"
+                       :status status
+                       :sessionId (:sessionId @state-atom)
+                       :at (now-ms)}
+                reason (assoc :reason reason))))
+
+(defn create-scheduler
+  [{:keys [state-atom emit-event effector]}]
+  (let [queue (atom [])
+        disposed? (atom false)]
+    (letfn [(enqueue! [step plan]
+              (let [entry (queue-entry step (count @queue) plan)]
+                (swap! queue conj entry)
+                entry))
+
+            (execute-step! [step command plan]
+              (let [now (now-ms)]
+                (enqueue! step plan)
+                (case (:op step)
+                  "apply-config"
+                  (do
+                    (swap! state-atom state/configure (:config command))
+                    (emit-status! emit-event state-atom (:status @state-atom) "configured"))
+
+                  "configure-provider"
+                  ((:configure effector) (:config @state-atom))
+
+                  "start-session"
+                  (do
+                    (swap! state-atom state/start-session now)
+                    (emit-status! emit-event state-atom "starting" nil))
+
+                  "request-provider-start"
+                  (do
+                    (emit-event (provider-request state-atom "start"
+                                                  {:config (:config @state-atom)
+                                                   :requestedAt now}))
+                    ((:start effector) (:sessionId @state-atom) (:config @state-atom)))
+
+                  "record-provider-started"
+                  (do
+                    (swap! state-atom state/provider-started now)
+                    (emit-status! emit-event state-atom "listening" "provider-started"))
+
+                  "stop-session"
+                  (do
+                    (swap! state-atom state/stop-session now (:reason step))
+                    (emit-status! emit-event state-atom "idle" (:reason step)))
+
+                  "request-provider-stop"
+                  (do
+                    (emit-event (provider-request state-atom "stop"
+                                                  {:reason (:reason step)
+                                                   :requestedAt now}))
+                    (if (= "abort" (:method step))
+                      ((:abort effector))
+                      ((:stop effector))))
+
+                  "reset-state"
+                  (do
+                    (swap! state-atom state/reset-state)
+                    (emit-status! emit-event state-atom "idle" "reset"))
+
+                  "publish-partial"
+                  (let [fact (transcript-fact state-atom "partial" step now)]
+                    (swap! state-atom state/record-partial fact)
+                    (emit-event fact))
+
+                  "publish-final"
+                  (let [fact (transcript-fact state-atom "final" step now)]
+                    (swap! state-atom state/record-final fact)
+                    (emit-event fact))
+
+                  "publish-interruption"
+                  (let [fact {:type "transcription.interruption"
+                              :agency "transcription"
+                              :targetAgency "conversation"
+                              :text (:text step)
+                              :confidence (:confidence step)
+                              :source (:source step)
+                              :sessionId (:sessionId @state-atom)
+                              :at now}]
+                    (swap! state-atom state/record-interruption fact)
+                    (emit-event fact))
+
+                  "publish-audio-interruption"
+                  (let [fact {:type "transcription.audioInterruption"
+                              :agency "transcription"
+                              :targetAgency "conversation"
+                              :timestamp (:timestamp step)
+                              :microphoneLevel (:microphoneLevel step)
+                              :referenceLevel (:referenceLevel step)
+                              :requiredLevel (:requiredLevel step)
+                              :at now}]
+                    (swap! state-atom state/record-interruption fact)
+                    (emit-event fact))
+
+                  "record-error"
+                  (do
+                    (swap! state-atom state/record-error (:message step) now (:retry step))
+                    (emit-event {:type "transcription.error"
+                                 :agency "transcription"
+                                 :message (:message step)
+                                 :retrying (:retry step)
+                                 :sessionId (:sessionId @state-atom)
+                                 :at now}))
+
+                  "request-provider-retry"
+                  (do
+                    (emit-event (provider-request state-atom "retry"
+                                                  {:message (:message step)
+                                                   :retryAfterMs (:retryAfterMs step)
+                                                   :retryCount (:retryCount @state-atom)
+                                                   :requestedAt now}))
+                    ((:retry effector)
+                     (:sessionId @state-atom)
+                     (:retryAfterMs step)))
+
+                  "publish-status"
+                  (emit-status! emit-event state-atom (:status step) (:reason step))
+
+                  "ignore"
+                  (let [ignored {:type "transcription.ignored"
+                                 :agency "transcription"
+                                 :reason (:reason step)
+                                 :commandType (:commandType step)
+                                 :at now}]
+                    (swap! state-atom state/record-ignored ignored)
+                    (emit-event ignored))
+
+                  "record-tts-status"
+                  (let [fact (:fact step)]
+                    (swap! state-atom state/record-tts-status fact)
+                    ((:sync-agent-speaking effector)
+                     (:agentSpeaking @state-atom))
+                    (emit-event fact))
+
+                  "prepare-agent-speech"
+                  (do
+                    (swap! state-atom state/prepare-agent-speech
+                           (:text step)
+                           (:append step))
+                    ((:sync-agent-speaking effector)
+                     (:agentSpeaking @state-atom)))
+
+                  "record-agent-word"
+                  (swap! state-atom state/record-agent-word (:word step))
+
+                  "fail"
+                  (emit-event {:type "error"
+                               :agency "transcription"
+                               :message (:reason step)
+                               :commandType (:commandType step)
+                               :at now})
+
+                  nil)))]
+      {:schedule
+       (fn [command plan]
+         (when-not @disposed?
+           (last (mapv #(execute-step! % command plan) (:steps plan)))))
+
+       :queue
+       (fn []
+         @queue)
+
+       :set-reference-track
+       (fn [track]
+         (when-not @disposed?
+           (let [plan {:agency "transcription"
+                       :commandType "setAgentAudioReferenceTrack"
+                       :createdAt (now-ms)}
+                 step {:op "set-reference-track"}]
+             (enqueue! step plan)
+             ((:set-reference-track effector) track))))
+
+       :dispose
+       (fn []
+         (reset! disposed? true)
+         (reset! queue [])
+         ((:dispose effector)))})))

package/src/polymer/transcription/service.cljs

@@ -0,0 +1,209 @@
+(ns polymer.transcription.service
+  (:require [clojure.string :as str]
+            [polymer.transcription.agency :as transcription-agency]
+            [polymer.transcription.domain :as domain]))
+
+;; Compatibility adapter for LoomLarge's historical TranscriptionService API.
+;; Recognition, microphone acquisition, AudioContext analysis, playback-reference
+;; comparison, and frame monitoring all remain private to the agency effector.
+
+(defn data-map
+  [value]
+  (cond
+    (map? value) value
+    value (js->clj value :keywordize-keys true)
+    :else {}))
+
+(defn js-call
+  [target method-name & args]
+  (when target
+    (when-let [method (aget target method-name)]
+      (when (fn? method)
+        (.apply method target (to-array args))))))
+
+(defn emit-set!
+  [listeners & args]
+  (doseq [listener @listeners]
+    (.apply listener nil (to-array args))))
+
+(defn promise-resolve
+  [value]
+  (.resolve js/Promise value))
+
+(defn compatibility-config
+  [config]
+  ;; Preserve the active LoomLarge barge-in defaults explicitly at the adapter
+  ;; boundary. Direct agency construction uses the same normalized defaults.
+  (merge {:agentFilteringEnabled true
+          :interruptDetectionEnabled true
+          :requireAgentReferenceForInterruption true}
+         (data-map config)))
+
+(defn create-service
+  [config callbacks]
+  (let [agency (transcription-agency/create-transcription-agency
+                (compatibility-config config))
+        transcript-listeners (atom #{})
+        boundary-listeners (atom #{})
+        interruption-listeners (atom #{})
+        disposed? (atom false)
+        last-status (atom "idle")
+        unsubscribe (atom nil)]
+    (letfn [(dispatch! [command]
+              (js-call agency "dispatch" (clj->js command)))
+
+            (emit-transcript! [event]
+              (let [text (:text event)
+                    final? (boolean (:isFinal event))]
+                (js-call callbacks "onTranscript" text final?)
+                (emit-set! transcript-listeners text final?)
+                (when final?
+                  (doseq [boundary
+                          (domain/boundary-events text (:at event))]
+                    (let [payload (clj->js boundary)]
+                      (js-call callbacks "onBoundary" payload)
+                      (emit-set! boundary-listeners payload))))))
+
+            (emit-status! [event]
+              (let [status (:status event)
+                    previous @last-status]
+                (reset! last-status status)
+                (when (and (= "listening" status)
+                           (not= "listening" previous))
+                  (js-call callbacks "onStart"))
+                (when (and (= "idle" status)
+                           (not= "idle" previous))
+                  (js-call callbacks "onEnd"))))
+
+            (emit-audio-interruption! [event]
+              (let [payload (clj->js
+                             (select-keys
+                              event
+                              [:timestamp
+                               :microphoneLevel
+                               :referenceLevel
+                               :requiredLevel]))]
+                (js-call callbacks "onInterruption" payload)
+                (emit-set! interruption-listeners payload)))
+
+            (handle-event! [value]
+              (when-not @disposed?
+                (let [event (data-map value)]
+                  (case (:type event)
+                    ("transcription.partial" "transcription.final")
+                    (emit-transcript! event)
+
+                    "transcription.audioInterruption"
+                    (emit-audio-interruption! event)
+
+                    "transcription.error"
+                    (js-call callbacks "onError"
+                             (js/Error. (:message event)))
+
+                    "transcription.status"
+                    (emit-status! event)
+
+                    nil))))
+
+            (handle-agent-speech! [value]
+              (let [event (data-map value)
+                    text (or (:phrase event)
+                             (when (seq (:words event))
+                               (str/join " " (:words event))))]
+                (case (:type event)
+                  "AGENT_SCRIPT"
+                  (dispatch! {:type "agentSpeechPrepared" :text text})
+
+                  "AGENT_START"
+                  (dispatch! {:type "agentSpeechObserved" :text text})
+
+                  ("END" "AGENT_DONE" "PLAYBACK_ENDED")
+                  (dispatch! {:type "agentSpeechEnded"})
+
+                  "WORD"
+                  (dispatch! {:type "agentSpeechWord" :word (:word event)})
+
+                  nil)))]
+      (reset! unsubscribe
+              (js-call agency "subscribeEvents" handle-event!))
+      #js {:startListening
+           (fn []
+             (if @disposed?
+               (.reject js/Promise
+                        (js/Error. "Transcription service is disposed"))
+               (let [result (js-call agency "start")
+                     snapshot (data-map (js-call agency "snapshot"))]
+                 (if (:lastError snapshot)
+                   (.reject js/Promise
+                            (js/Error.
+                             (or (:lastError snapshot)
+                                 "speech-recognition-start-error")))
+                   (promise-resolve result)))))
+
+           :stopListening
+           (fn []
+             (js-call agency "stop"))
+
+           :handleAgentSpeech handle-agent-speech!
+
+           :prepareAgentSpeech
+           (fn [text]
+             (dispatch! {:type "agentSpeechPrepared" :text text}))
+
+           :notifyAgentSpeech
+           (fn [text]
+             (dispatch! {:type "agentSpeechObserved" :text text}))
+
+           :notifyAgentSpeechEnd
+           (fn []
+             (dispatch! {:type "agentSpeechEnded"}))
+
+           :setAgentAudioReferenceTrack
+           (fn [track]
+             (js-call agency "setAgentAudioReferenceTrack" track))
+
+           :onBoundary
+           (fn [listener]
+             (swap! boundary-listeners conj listener)
+             (fn [] (swap! boundary-listeners disj listener)))
+
+           :onTranscript
+           (fn [listener]
+             (swap! transcript-listeners conj listener)
+             (fn [] (swap! transcript-listeners disj listener)))
+
+           :onInterruption
+           (fn [listener]
+             (swap! interruption-listeners conj listener)
+             (fn [] (swap! interruption-listeners disj listener)))
+
+           :getState
+           (fn []
+             (js-call agency "snapshot"))
+
+           :updateConfig
+           (fn [updates]
+             (dispatch! {:type "configure"
+                         :config (data-map updates)}))
+
+           :dispose
+           (fn []
+             (when-not @disposed?
+               (reset! disposed? true)
+               (when-let [stop @unsubscribe]
+                 (stop)
+                 (reset! unsubscribe nil))
+               (reset! transcript-listeners #{})
+               (reset! boundary-listeners #{})
+               (reset! interruption-listeners #{})
+               (js-call agency "dispose")))})))
+
+(defn TranscriptionService
+  ([] (create-service nil nil))
+  ([config] (create-service config nil))
+  ([config callbacks] (create-service config callbacks)))
+
+(defn createTranscriptionService
+  ([] (TranscriptionService nil nil))
+  ([config] (TranscriptionService config nil))
+  ([config callbacks] (TranscriptionService config callbacks)))