@lovelace_lol/polymer 0.0.6 → 0.0.8

package/src/polymer/character.cljs

@@ -1,403 +0,0 @@
-(ns polymer.character
-  (:require [polymer.animation.agency :as animation]
-            [polymer.blink.agency :as blink]
-            [polymer.camera-context.agency :as camera-context]
-            [polymer.conversation.agency :as conversation]
-            [polymer.eye-head.agency :as eye-head]
-            [polymer.gaze.agency :as gaze]
-            [polymer.gesture.agency :as gesture]
-            [polymer.lipsync.agency :as lipsync]
-            [polymer.prosodic.agency :as prosodic]
-            [polymer.society :as society]
-            [polymer.stream :as stream]
-            [polymer.transcription.agency :as transcription]
-            [polymer.tts.agency :as tts]))
-
-;; A character is a network of Polymer agencies.
-;;
-;; LoomLarge may still consume streams from legacy Latticework services during
-;; the migration, but it should not consume Polymer animation events and turn
-;; them into animation calls. Inside Polymer, Blink emits blink intent and fast
-;; blink facts, Camera Context emits gaze facts, Transcription emits transcript
-;; facts, Conversation emits speech requests, TTS emits speech timing facts,
-;; LipSync emits mouth animation intent, Gesture emits arm/hand animation intent,
-;; Prosodic emits speech/blink expression intent, and Animation talks directly
-;; to Embody. Hair appearance and physics are Embody runtime concerns, not a
-;; Polymer behavioral agency.
-
-(defn- with-source-agency [event route]
-  (assoc event :sourceAgency (:from route)))
-
-(defn- animation-command [event route]
-  (when (= "animation" (:to route))
-    (case (:type event)
-      "animation.requestScheduleSnippet"
-      {:type "scheduleSnippet"
-       :sourceAgency (:agency event)
-       :snippet (:snippet event)
-       :options (:options event)}
-
-      "animation.requestRemoveSnippet"
-      {:type "removeSnippet"
-       :sourceAgency (:agency event)
-       :name (:name event)}
-
-      "animation.requestSeekSnippet"
-      {:type "seekSnippet"
-       :sourceAgency (:agency event)
-       :name (:name event)
-       :offsetSec (:offsetSec event)}
-
-      nil)))
-
-(defn- transcription-command [event]
-  (case (:type event)
-    "transcription.final"
-    {:type "transcript.final"
-     :text (:text event)
-     :source "transcription"
-     :confidence (:confidence event)
-     :sequence (:sequence event)
-     :sessionId (:sessionId event)
-     :at (:at event)}
-
-    "transcription.interruption"
-    {:type "interrupt"
-     :reason "transcription-interruption"
-     :text (:text event)
-     :source "transcription"}
-
-    "transcription.audioInterruption"
-    {:type "interrupt"
-     :reason "audio-interruption"
-     :event event
-     :source "transcription"}
-
-    nil))
-
-(defn- conversation-command [event route]
-  (case (:type event)
-    "tts.requestSpeak"
-    (:command event)
-
-    "conversation.cancelRequested"
-    (if (= "tts" (:to route))
-      {:type "stop"
-       :reason (:reason event)}
-      (with-source-agency event route))
-
-    (with-source-agency event route)))
-
-(defn- tts-command [event route]
-  (case (:type event)
-    "lipSync.command"
-    (:command event)
-
-    "ttsStatusChanged"
-    (let [status (get-in event [:state :status])]
-      (case (:to route)
-        "conversation" {:type "tts.status"
-                        :status status}
-        "transcription" {:type "tts.status"
-                         :status status
-                         :speaking (get-in event [:state :speaking])
-                         :state (:state event)}
-        nil))
-
-    "ttsSpeechStarted"
-    (case (:to route)
-      "prosodic" {:type "speechStarted"
-                  :sourceAgency "tts"
-                  :name (:name event)
-                  :engine (:engine event)}
-      "conversation" {:type "tts.status"
-                      :status "speaking"}
-      "transcription" event
-      nil)
-
-    "ttsWordBoundary"
-    (when (= "prosodic" (:to route))
-      {:type "wordBoundary"
-       :sourceAgency "tts"
-       :word (:word event)
-       :wordIndex (:wordIndex event)
-       :observedElapsedSec (:observedElapsedSec event)
-       :hostElapsedSec (:hostElapsedSec event)})
-
-    "ttsSpeechStopped"
-    (case (:to route)
-      "prosodic" {:type "speechStopped"
-                  :sourceAgency "tts"
-                  :reason (:reason event)}
-      "conversation" {:type "tts.status"
-                      :status "idle"}
-      "transcription" event
-      nil)
-
-    "ttsSpeechEnded"
-    (case (:to route)
-      "prosodic" {:type "speechStopped"
-                  :sourceAgency "tts"
-                  :reason "completed"}
-      "conversation" {:type "tts.status"
-                      :status "idle"}
-      "transcription" event
-      nil)
-
-    (with-source-agency event route)))
-
-(defn- routed-command [event route]
-  (case (:type event)
-    ("animation.requestScheduleSnippet"
-     "animation.requestRemoveSnippet"
-     "animation.requestSeekSnippet")
-    (animation-command event route)
-
-    "signal"
-    (if (and (= "blink" (:from route))
-             (= "prosodic" (:to route))
-             (= "blink-fast" (:signal event)))
-      {:type "blinkFast"
-       :sourceAgency "blink"
-       :plan (:plan event)}
-      (with-source-agency event route))
-
-    ("eyeHeadTracking.requestGaze"
-     "eyeHeadTracking.requestReset"
-     "eyeHeadTracking.requestCancel"
-     "camera.fact"
-     "camera.stale")
-    event
-
-    ("transcription.final"
-     "transcription.interruption"
-     "transcription.audioInterruption")
-    (transcription-command event)
-
-    ("conversation.userUtterance"
-     "conversation.agentUtterance"
-     "conversation.requestResponse"
-     "tts.requestSpeak"
-     "conversation.cancelRequested")
-    (conversation-command event route)
-
-    ("lipSync.command"
-     "ttsStatusChanged"
-     "ttsSpeechStarted"
-     "ttsWordBoundary"
-     "ttsSpeechStopped"
-     "ttsSpeechEnded")
-    (tts-command event route)
-
-    (with-source-agency event route)))
-
-(defn canonical-agency-event
-  "Attach the source known by the agency subscription to an outgoing event.
-
-  Agency payloads are plain data and may be malformed or supplied by an
-  injected provider. The character router must not let a payload select another
-  agency's outgoing graph edges by spoofing its `agency` field."
-  [source event]
-  (assoc event :agency source))
-
-(defn create-character-agencies [config]
-  (let [input-stream (stream/create-stream)
-        event-stream (stream/create-stream)
-        emit-input (:emit input-stream)
-        emit-event (:emit event-stream)
-        agency-society (atom (society/normalize-agency-society
-                              (when config (aget config "agencySociety"))))
-        animation-agency (animation/create-animation-agency
-                          (society/agency-config config @agency-society "animation"))
-        blink-agency (blink/create-blink-agency
-                      (society/agency-config config @agency-society "blink"))
-        gaze-agency (gaze/create-gaze-agency
-                     (society/agency-config config @agency-society "gaze"))
-        eye-head-agency (eye-head/create-eye-head-tracking-agency
-                         (society/agency-config config @agency-society "eyeHeadTracking"))
-        gesture-agency (gesture/create-gesture-agency
-                        (society/agency-config config @agency-society "gesture"))
-        camera-context-agency (camera-context/create-camera-context-agency
-                               (society/agency-config config @agency-society "cameraContext"))
-        transcription-agency (transcription/create-transcription-agency
-                              (society/agency-config config @agency-society "transcription"))
-        conversation-config (society/agency-config
-                             config @agency-society "conversation")
-        ;; The provider is injected once into Conversation's private effector.
-        ;; The character router never invokes provider functions itself.
-        conversation-provider (when config (aget config "conversationProvider"))
-        conversation-options (if conversation-provider
-                               (let [options (js/Object.assign
-                                              #js {}
-                                              (or conversation-config #js {}))]
-                                 (aset options "provider" conversation-provider)
-                                 options)
-                               conversation-config)
-        conversation-agency (conversation/create-conversation-agency
-                             conversation-options)
-        tts-agency (tts/create-tts-agency
-                    (society/agency-config config @agency-society "tts"))
-        lipsync-runtime (when config (aget config "lipSyncRuntime"))
-        lipsync-agency (lipsync/create-lipsync-agency
-                        (society/agency-config config @agency-society "lipSync")
-                        lipsync-runtime)
-        prosodic-agency (prosodic/create-prosodic-agency
-                         (society/agency-config config @agency-society "prosodic"))
-        unsubscribers (atom [])
-        disposed? (atom false)]
-    (letfn [(track! [unsubscribe]
-              (swap! unsubscribers conj unsubscribe))
-
-            (agency-by-name [name]
-              (case name
-                "animation" animation-agency
-                "blink" blink-agency
-                "gaze" gaze-agency
-                "eyeHeadTracking" eye-head-agency
-                "gesture" gesture-agency
-                "cameraContext" camera-context-agency
-                "transcription" transcription-agency
-                "conversation" conversation-agency
-                "tts" tts-agency
-                "lipSync" lipsync-agency
-                "prosodic" prosodic-agency
-                nil))
-
-            (dispatch-to! [name command]
-              (when-let [target (agency-by-name name)]
-                (when-let [dispatch (aget target "dispatch")]
-                  (.call dispatch target (clj->js command))
-                  true)))
-
-            (route-event! [source event]
-              (doseq [route (society/route-contexts @agency-society
-                                                     source
-                                                     event)]
-                (when-let [command (routed-command event route)]
-                  (when (dispatch-to! (:to route) (assoc command :society route))
-                    ;; Route telemetry is emitted only after the receiving
-                    ;; agency accepted the command. Hosts can therefore draw
-                    ;; the real society traffic without reimplementing route
-                    ;; matching, credit admission, or required-edge rules.
-                    ;; Emitting directly to the character event stream also
-                    ;; prevents this diagnostic event from entering routing
-                    ;; again and recursively producing more commands.
-                    (emit-event {:type "society.routeActivated"
-                                 :agency "character"
-                                 :edgeId (:edgeId route)
-                                 :from source
-                                 :to (:to route)
-                                 :eventType (:type event)
-                                 :credit (:credit route)
-                                 :at (.now js/Date)})))))
-
-            (emit-agency-event! [source event]
-              (let [payload (canonical-agency-event
-                             source
-                             (js->clj event :keywordize-keys true))]
-                (route-event! source payload)
-                (emit-event payload)))
-
-            (dispatch! [message]
-              (when-not @disposed?
-                (let [payload (js->clj message :keywordize-keys true)]
-                  ;; Input is still observable for tests/workers, but the write
-                  ;; path routes to agencies directly inside Polymer.
-                  (emit-input {:type "command"
-                               :agency (:agency payload)
-                               :message payload})
-                  (let [name (:agency payload)]
-                    (cond
-                      (nil? (agency-by-name name))
-                      (emit-event {:type "error"
-                                   :agency (or name "unknown")
-                                   :message "Unknown Polymer agency"})
-
-                      (not (society/agency-enabled? @agency-society name))
-                      (emit-event {:type "agencyDisabled"
-                                   :agency name
-                                   :message "Polymer agency is disabled by agencySociety"})
-
-                      :else
-                      (dispatch-to! name (:command payload)))))))
-
-            (snapshot! []
-              (clj->js {:blink (js->clj (.snapshot ^js blink-agency) :keywordize-keys true)
-                        :gaze (js->clj (.snapshot ^js gaze-agency) :keywordize-keys true)
-                        :eyeHeadTracking (js->clj (.snapshot ^js eye-head-agency) :keywordize-keys true)
-                        :gesture (js->clj (.snapshot ^js gesture-agency) :keywordize-keys true)
-                        :cameraContext (js->clj (.snapshot ^js camera-context-agency) :keywordize-keys true)
-                        :transcription (js->clj (.snapshot ^js transcription-agency) :keywordize-keys true)
-                        :conversation (js->clj (.snapshot ^js conversation-agency) :keywordize-keys true)
-                        :tts (js->clj (.snapshot ^js tts-agency) :keywordize-keys true)
-                        :lipSync (js->clj (.snapshot ^js lipsync-agency) :keywordize-keys true)
-                        :prosodic (js->clj (.snapshot ^js prosodic-agency) :keywordize-keys true)
-                        :animation (js->clj (.snapshot ^js animation-agency) :keywordize-keys true)
-                        :agencySociety @agency-society}))
-
-            (update-society-routing! [next-society]
-              (when-not @disposed?
-                (let [normalized (society/normalize-agency-society next-society)]
-                  ;; This live update changes route admission only. Agency-local
-                  ;; configure/priors still apply when the character system is
-                  ;; created, so a graph editor cannot bypass local planners.
-                  (reset! agency-society normalized)
-                  (emit-input {:type "agencySociety.update"
-                               :agencySociety normalized})
-                  (emit-event {:type "agencySocietyUpdated"
-                               :agency "character"
-                               :agencySociety normalized})
-                  (clj->js normalized))))
-
-            ]
-      ;; Fan-in agency events to one character-level event stream for tests,
-      ;; workers, and future non-React observers. LoomLarge does not need to
-      ;; consume this stream for Polymer animation playback.
-      (track! (.subscribeEvents ^js animation-agency #(emit-agency-event! "animation" %)))
-      (track! (.subscribeEvents ^js blink-agency #(emit-agency-event! "blink" %)))
-      (track! (.subscribeEvents ^js gaze-agency #(emit-agency-event! "gaze" %)))
-      (track! (.subscribeEvents ^js eye-head-agency #(emit-agency-event! "eyeHeadTracking" %)))
-      (track! (.subscribeEvents ^js gesture-agency #(emit-agency-event! "gesture" %)))
-      (track! (.subscribeEvents ^js camera-context-agency #(emit-agency-event! "cameraContext" %)))
-      (track! (.subscribeEvents ^js transcription-agency #(emit-agency-event! "transcription" %)))
-      (track! (.subscribeEvents ^js conversation-agency #(emit-agency-event! "conversation" %)))
-      (track! (.subscribeEvents ^js tts-agency #(emit-agency-event! "tts" %)))
-      (track! (.subscribeEvents ^js lipsync-agency #(emit-agency-event! "lipSync" %)))
-      (track! (.subscribeEvents ^js prosodic-agency #(emit-agency-event! "prosodic" %)))
-      (let [api #js {:dispatch dispatch!
-                     :input (stream/writable-port input-stream dispatch!)
-                     :events (stream/readable-port event-stream)
-                     :snapshot snapshot!
-                     :updateSocietyRouting update-society-routing!
-                     :agency (fn [name]
-                               (when (society/agency-enabled? @agency-society name)
-                                 (agency-by-name name)))
-                     :subscribeInput (fn [listener] ((:subscribe input-stream) listener))
-                     :subscribeEvents (fn [listener] ((:subscribe event-stream) listener))
-                     :subscribe (fn [listener] ((:subscribe event-stream) listener))
-                     :subscribeStatus (fn [listener] ((:subscribe event-stream) listener))
-                     :dispose (fn []
-                                (when-not @disposed?
-                                  (reset! disposed? true)
-                                  (doseq [unsubscribe @unsubscribers]
-                                    (unsubscribe))
-                                  (reset! unsubscribers [])
-                                  (.dispose ^js blink-agency)
-                                  (.dispose ^js gaze-agency)
-                                  (.dispose ^js eye-head-agency)
-                                  (.dispose ^js gesture-agency)
-                                  (.dispose ^js camera-context-agency)
-                                  (.dispose ^js transcription-agency)
-                                  (.dispose ^js conversation-agency)
-                                  (.dispose ^js tts-agency)
-                                  (.dispose ^js lipsync-agency)
-                                  (.dispose ^js prosodic-agency)
-                                  (.dispose ^js animation-agency)
-                                  ((:dispose input-stream))
-                                  ((:dispose event-stream))))}]
-        (js/Object.defineProperty
-         api
-         "agencySociety"
-         #js {:enumerable true
-              :get #(clj->js @agency-society)})
-        api))))

package/src/polymer/conversation/agency.cljs

@@ -1,83 +0,0 @@
-(ns polymer.conversation.agency
-  (:require [polymer.conversation.domain :as domain]
-            [polymer.conversation.effector :as effector]
-            [polymer.conversation.planner :as planner]
-            [polymer.conversation.scheduler :as scheduler]
-            [polymer.conversation.state :as state]
-            [polymer.stream :as stream]))
-
-;; Conversation is a peer agency in the Polymer character society. It accepts
-;; transcript, response, and interruption facts as data; plans local turn-taking
-;; work; schedules those actions; then emits requests/facts that TTS, Gaze,
-;; Prosodic, and other agencies can decide how to handle.
-
-(defn now-ms
-  []
-  (.now js/Date))
-
-(defn js-command
-  [type value]
-  #js {:type type :value value})
-
-(defn create-conversation-agency
-  [config]
-  (let [provider (if (map? config)
-                   (or (:provider config)
-                       (:conversationProvider config))
-                   (when config
-                     (or (aget config "provider")
-                         (aget config "conversationProvider"))))
-        config-map (domain/data-map config)
-        state-config (dissoc config-map :provider :conversationProvider)
-        input-stream (stream/create-stream)
-        event-stream (stream/create-stream)
-        state-atom (atom (state/config->state state-config))
-        disposed? (atom false)
-        emit-input (:emit input-stream)
-        emit-event (:emit event-stream)
-        scheduler-atom (atom nil)]
-    (letfn [(dispatch! [command]
-              (when-not @disposed?
-                (let [payload (domain/data-map command)
-                      plan (planner/plan-command payload @state-atom (now-ms))]
-                  ;; Input is observable for workers/tests and for future
-                  ;; diagnostics. It is not host application state and should
-                  ;; not be mirrored into a UI on every agency message.
-                  (emit-input {:type "command"
-                               :agency "conversation"
-                               :command payload})
-                  (when-let [agency-scheduler @scheduler-atom]
-                    ((:schedule agency-scheduler) payload plan)))))
-            (dispatch-type! [type]
-              (dispatch! #js {:type type}))]
-      (let [agency-scheduler (scheduler/create-scheduler
-                              {:state-atom state-atom
-                               :emit-event emit-event
-                               :dispatch-command dispatch!
-                               :provider-effector
-                               (effector/create-provider-effector provider)})]
-        (reset! scheduler-atom agency-scheduler)
-        #js {:dispatch dispatch!
-             :snapshot (fn [] (state/visible-state @state-atom))
-             :input (stream/writable-port input-stream dispatch!)
-             :events (stream/readable-port event-stream)
-             :subscribeInput (fn [listener] ((:subscribe input-stream) listener))
-             :subscribeEvents (fn [listener] ((:subscribe event-stream) listener))
-             :subscribe (fn [listener] ((:subscribe event-stream) listener))
-             :subscribeStatus (fn [listener] ((:subscribe event-stream) listener))
-             :start (fn [] (dispatch-type! "start"))
-             :stop (fn [] (dispatch-type! "stop"))
-             :reset (fn [] (dispatch-type! "reset"))
-             :interrupt (fn
-                          ([] (dispatch-type! "interrupt"))
-                          ([reason] (dispatch! #js {:type "interrupt" :reason reason})))
-             :setAutoRespond (fn [value]
-                               (dispatch! #js {:type "configure"
-                                               :config #js {:autoRespond value}}))
-             :queue (fn [] (clj->js ((:queue agency-scheduler))))
-             :dispose (fn []
-                        (when-not @disposed?
-                          (reset! disposed? true)
-                          ((:dispose agency-scheduler))
-                          ((:dispose input-stream))
-                          ((:dispose event-stream))))}))))

package/src/polymer/conversation/domain.cljs

@@ -1,35 +0,0 @@
-(ns polymer.conversation.domain
-  (:require [clojure.string :as str]))
-
-;; Pure Conversation transforms live here so command normalization is shared by
-;; state, planner, and the JS-facing agency boundary.
-
-(defn data-map
-  [value]
-  (cond
-    (map? value) value
-    value (js->clj value :keywordize-keys true)
-    :else {}))
-
-(defn clean-text
-  [value]
-  (let [text (str/trim (or value ""))]
-    (when (pos? (count text))
-      text)))
-
-(defn text-or
-  [value fallback]
-  (or (clean-text value) fallback))
-
-(defn user-text
-  [command]
-  (clean-text (or (:text command)
-                  (:transcript command)
-                  (:utterance command))))
-
-(defn agent-text
-  [command]
-  (clean-text (or (:agentText command)
-                  (:responseText command)
-                  (:text command)
-                  (:utterance command))))

package/src/polymer/conversation/effector.cljs

@@ -1,130 +0,0 @@
-(ns polymer.conversation.effector
-  (:require [polymer.conversation.domain :as domain]))
-
-;; The provider effector is the only Conversation code allowed to invoke an
-;; external LLM/backend provider. It receives already-planned request data from
-;; the scheduler and reports plain completion data back to the agency.
-
-(defn provider-call
-  [provider]
-  (cond
-    (fn? provider)
-    {:target nil
-     :respond provider}
-
-    (and provider (fn? (aget provider "respond")))
-    {:target provider
-     :respond (aget provider "respond")}
-
-    :else nil))
-
-(defn thenable?
-  [value]
-  (and value (fn? (aget value "then"))))
-
-(defn cleanup-callback
-  [value]
-  (cond
-    (fn? value)
-    value
-
-    :else
-    (when value
-      (some (fn [method-name]
-              (when-let [method (aget value method-name)]
-                (when (fn? method)
-                  #(.call method value))))
-            ["cancel" "abort" "stop" "dispose"]))))
-
-(defn response-data
-  [response]
-  (cond
-    (string? response) {:text response}
-    (map? response) response
-    response (domain/data-map response)
-    :else {}))
-
-(defn error-message
-  [error]
-  (or (domain/clean-text (when error (aget error "message")))
-      (domain/clean-text (when (string? error) error))
-      (domain/clean-text (str error))
-      "conversation-provider-error"))
-
-(defn create-provider-effector
-  [provider]
-  (let [call (provider-call provider)
-        active (atom {})
-        disposed? (atom false)]
-    (letfn [(active-token? [request-id token]
-              (identical? token (get-in @active [request-id :token])))
-
-            (settle! [request-id token callback value]
-              (when (and (not @disposed?)
-                         (active-token? request-id token))
-                (swap! active dissoc request-id)
-                (callback value)))
-
-            (cancel-entry! [request-id]
-              (when-let [{:keys [cleanup]} (get @active request-id)]
-                (swap! active dissoc request-id)
-                (when cleanup
-                  (try
-                    (cleanup)
-                    (catch :default _
-                      nil)))))
-
-            (remember-cleanup! [request-id token cleanup]
-              (when (and cleanup (active-token? request-id token))
-                (swap! active assoc-in [request-id :cleanup] cleanup)))
-
-            (invoke! [request on-success on-error]
-              (when (and call (not @disposed?))
-                (let [request-id (:requestId request)
-                      token (js-obj)
-                      succeed! #(settle! request-id token on-success
-                                         (response-data %))
-                      fail! #(settle! request-id token on-error
-                                      {:message (error-message %)})
-                      request-js (clj->js (dissoc request
-                                                  :type
-                                                  :agency
-                                                  :targetAgency))]
-                  (cancel-entry! request-id)
-                  (swap! active assoc request-id {:token token
-                                                  :cleanup nil})
-                  (try
-                    (let [result (.call (:respond call)
-                                        (:target call)
-                                        request-js
-                                        succeed!
-                                        fail!)
-                          cleanup (cleanup-callback result)]
-                      (cond
-                        (thenable? result)
-                        (do
-                          (remember-cleanup! request-id token cleanup)
-                          (.then result succeed! fail!))
-
-                        cleanup
-                        (remember-cleanup! request-id token cleanup)
-
-                        (some? result)
-                        (succeed! result)
-
-                        :else nil))
-                    (catch :default error
-                      (fail! error))))))
-
-            (cancel-all! []
-              (doseq [request-id (keys @active)]
-                (cancel-entry! request-id)))]
-      {:available? (boolean call)
-       :invoke invoke!
-       :cancel cancel-entry!
-       :cancel-all cancel-all!
-       :dispose
-       (fn []
-         (when-not @disposed?
-           (cancel-all!)
-           (reset! disposed? true)))})))