@lovelace_lol/polymer 0.0.7 → 0.0.8

package/src/polymer/transcription/planner.cljs

@@ -1,203 +0,0 @@
-(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

@@ -1,225 +0,0 @@
-(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

@@ -1,209 +0,0 @@
-(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)))