@lovelace_lol/polymer 0.0.1

package/src/polymer/conversation/service.cljs

@@ -0,0 +1,329 @@
+(ns polymer.conversation.service
+  (:require [polymer.conversation.agency :as conversation-agency]))
+
+;; Compatibility adapter for LoomLarge's old generator-based JavaScript API.
+;; This is not the Conversation agency implementation. It exists so current
+;; callers can keep their historical service shape while the agency owns
+;; conversation state, planning, scheduling, and stream facts.
+;;
+;; Important: the generator (LoomLarge AI Chat) owns LLM replies. The orphan
+;; agency inside this adapter must not auto-respond / wait on a missing
+;; conversation-provider, or turn-taking freezes after the first user utterance.
+;;
+;; Interrupt parity with Latticework:
+;; - Audio barge-in via transcription.onInterruption
+;; - Optional transcript fallback via allowTranscriptInterruptionFallback
+;; - Ignore non-interrupt finals while the agent is still speaking
+;; - Sync TTS playback reference track into transcription for AEC barge-in
+
+(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 promise-resolve [value]
+  (.resolve js/Promise value))
+
+(defn promise-reject [value]
+  (.reject js/Promise value))
+
+(defn now-ms []
+  (.now js/Date))
+
+(defn service-handles [config]
+  ;; Keep live JS service handles out of js->clj. Converting them to CLJ maps
+  ;; breaks later aget/method calls (eye/head setSpeaking became a silent no-op).
+  {:eyeHeadTracking (when config (aget config "eyeHeadTracking"))
+   :prosodicService (when config (aget config "prosodicService"))})
+
+(defn default-config [config]
+  (let [handles (service-handles config)
+        plain (dissoc (data-map config) :eyeHeadTracking :prosodicService)]
+    (merge {:autoListen true
+            :detectInterruptions true
+            :minSpeakTime 500
+            :allowTranscriptInterruptionFallback false
+            :eyeHeadTracking (:eyeHeadTracking handles)
+            :prosodicService (:prosodicService handles)}
+           plain
+           handles)))
+
+(defn generator-next [flow input has-input?]
+  (if has-input?
+    (.next flow input)
+    (.next flow)))
+
+(defn result-value [result]
+  (aget result "value"))
+
+(defn result-done? [result]
+  (boolean (aget result "done")))
+
+(defn create-service [tts transcription config callbacks]
+  (let [config-atom (atom (default-config config))
+        context (atom {:state "idle"
+                       :lastUserSpeech nil
+                       :lastAgentSpeech nil
+                       :isInterrupted false
+                       :speakStartTime nil})
+        ;; Generator owns replies; disable agency autoRespond so transcriptFinal
+        ;; does not emit orphaned conversation.requestResponse with no provider.
+        agency (conversation-agency/create-conversation-agency
+                #js {:autoRespond false
+                     :maxHistory (or (:maxHistory @config-atom) 40)})
+        flow-atom (atom nil)
+        disposed? (atom false)
+        unsubscribers (atom [])
+        playback-unsub (atom nil)
+        agent-speech-active? (atom false)
+        pending-interrupted-transcript (atom nil)]
+    (letfn [(dispatch! [command]
+              (js-call agency "dispatch" (clj->js command)))
+            (set-state! [state]
+              (swap! context assoc :state state)
+              (js-call callbacks "onStateChange" state))
+            (eye-head []
+              (:eyeHeadTracking @config-atom))
+            (prosodic []
+              (:prosodicService @config-atom))
+            (set-speaking! [value]
+              (when-let [service (eye-head)]
+                (js-call service "setSpeaking" value)))
+            (set-listening! [value]
+              (when-let [service (eye-head)]
+                (js-call service "setListening" value)))
+            (notify-error! [error]
+              (js-call callbacks "onError" error))
+            (clear-playback-unsub! []
+              (when-let [unsubscribe @playback-unsub]
+                (unsubscribe)
+                (reset! playback-unsub nil)))
+            (sync-agent-audio-reference-track! []
+              (let [track (or (js-call tts "getPlaybackReferenceTrack") nil)]
+                (js-call transcription "setAgentAudioReferenceTrack" track)))
+            (start-listening! []
+              (when-not @disposed?
+                (set-speaking! false)
+                (set-listening! true)
+                (set-state! "userSpeaking")
+                (-> (promise-resolve (js-call transcription "startListening"))
+                    (.catch (fn [error]
+                              (when-not @disposed?
+                                (notify-error! error)))))))
+            (stop-listening! []
+              (set-listening! false)
+              (js-call transcription "stopListening"))
+            (arm-interruption-listening! []
+              (if (:detectInterruptions @config-atom)
+                (-> (promise-resolve (js-call transcription "startListening"))
+                    (.catch (fn [error]
+                              (when-not @disposed?
+                                (notify-error! error)
+                                nil))))
+                (promise-resolve nil)))
+            (stop-speaking-behaviors! []
+              (set-speaking! false)
+              (js-call (prosodic) "stopTalking"))
+            (can-interrupt-agent? []
+              (and (:detectInterruptions @config-atom)
+                   (not (:isInterrupted @context))
+                   (= "agentSpeaking" (:state @context))
+                   (some? (:speakStartTime @context))
+                   (>= (- (now-ms) (:speakStartTime @context))
+                       (:minSpeakTime @config-atom))))
+            (handle-interruption! [source event]
+              (when (can-interrupt-agent?)
+                (js/console.log (str "[ConversationService] Handling interruption from " source))
+                (swap! context assoc :isInterrupted true)
+                (dispatch! {:type "interrupt"
+                            :reason source
+                            :event (data-map event)})
+                (js-call tts "stop")
+                (stop-speaking-behaviors!)
+                (set-state! "interrupted")
+                ;; Only surface a user-speech callback when we have text (transcript
+                ;; fallback). Audio barge-in should not emit an empty final utterance.
+                (let [text (str (or (:text (data-map event)) ""))]
+                  (when (pos? (count text))
+                    (js-call callbacks "onUserSpeech" text true true)))))
+            (finish-agent-speech! []
+              (clear-playback-unsub!)
+              (reset! agent-speech-active? false)
+              (stop-speaking-behaviors!)
+              (js-call transcription "notifyAgentSpeechEnd")
+              (if-let [pending @pending-interrupted-transcript]
+                (do
+                  (reset! pending-interrupted-transcript nil)
+                  (submit-user-input! pending))
+                (cond
+                  (:isInterrupted @context)
+                  (start-listening!)
+
+                  (:autoListen @config-atom)
+                  (start-listening!)
+
+                  :else
+                  (set-state! "idle"))))
+            (speak-agent-text! [text]
+              (let [utterance (str text)]
+                (reset! agent-speech-active? true)
+                (reset! pending-interrupted-transcript nil)
+                (swap! context assoc
+                       :lastAgentSpeech utterance
+                       :speakStartTime nil
+                       :isInterrupted false)
+                (dispatch! {:type "agentUtterance"
+                            :text utterance
+                            :source "conversationService"})
+                (js-call callbacks "onAgentUtterance" utterance)
+                (sync-agent-audio-reference-track!)
+                (js-call transcription "prepareAgentSpeech" utterance)
+                (set-listening! false)
+                (set-speaking! true)
+                (when-let [service (eye-head)]
+                  (js-call service "setGazeTarget" #js {:x 0 :y 0 :z 0}))
+                (js-call (prosodic) "startTalking")
+                (set-state! "agentSpeaking")
+                (-> (arm-interruption-listening!)
+                    (.then (fn [_]
+                             (when-not @disposed?
+                               (clear-playback-unsub!)
+                               (when-let [unsubscribe (js-call tts "onPlaybackStart"
+                                                               (fn []
+                                                                 (when-not @disposed?
+                                                                   (swap! context assoc :speakStartTime (now-ms))
+                                                                   (sync-agent-audio-reference-track!)
+                                                                   (js-call transcription "notifyAgentSpeech" utterance))))]
+                                 (reset! playback-unsub unsubscribe))
+                               (js-call tts "speak" utterance))))
+                    (.then (fn [_result]
+                             (when-not @disposed?
+                               (finish-agent-speech!)))
+                           (fn [error]
+                             (when-not @disposed?
+                               (clear-playback-unsub!)
+                               (reset! agent-speech-active? false)
+                               (stop-speaking-behaviors!)
+                               (js-call transcription "notifyAgentSpeechEnd")
+                               (set-state! "idle")
+                               (notify-error! error)))))))
+            (handle-yield! [yielded]
+              (-> (promise-resolve yielded)
+                  (.then (fn [value]
+                           (when-not @disposed?
+                             (if (and (string? value) (pos? (count value)))
+                               (speak-agent-text! value)
+                               (start-listening!))))
+                         (fn [error]
+                           (when-not @disposed?
+                             (set-state! "idle")
+                             (notify-error! error))))))
+            (run-flow! [input has-input?]
+              (when-let [flow @flow-atom]
+                (try
+                  (set-state! "processing")
+                  (let [result (generator-next flow input has-input?)]
+                    (if (result-done? result)
+                      (set-state! "idle")
+                      (handle-yield! (result-value result))))
+                  (catch :default error
+                    (set-state! "idle")
+                    (notify-error! error)))))
+            (submit-user-input! [text]
+              (when-not @disposed?
+                (let [utterance (str text)]
+                  (swap! context assoc :lastUserSpeech utterance)
+                  (dispatch! {:type "transcriptFinal"
+                              :text utterance
+                              :source "conversationService"})
+                  (stop-listening!)
+                  (run-flow! utterance true))))
+            (transcript-handler [text is-final]
+              (when (and (:allowTranscriptInterruptionFallback @config-atom)
+                         (can-interrupt-agent?))
+                (handle-interruption! "transcript" #js {:source "transcript"
+                                                        :timestamp (now-ms)
+                                                        :text text}))
+              (let [is-interruption (or (:isInterrupted @context)
+                                        (= "interrupted" (:state @context)))]
+                (js-call callbacks "onUserSpeech" text is-final is-interruption)
+                (when is-final
+                  (cond
+                    @agent-speech-active?
+                    (if is-interruption
+                      (reset! pending-interrupted-transcript text)
+                      (js/console.debug "[ConversationService] Ignoring final transcript during uninterrupted agent speech:" text))
+
+                    :else
+                    (submit-user-input! text)))))
+            (interruption-handler [event]
+              (handle-interruption! "audio" event))]
+      (when-let [unsubscribe (js-call transcription "onTranscript" transcript-handler)]
+        (swap! unsubscribers conj unsubscribe))
+      (when-let [unsubscribe (js-call transcription "onInterruption" interruption-handler)]
+        (swap! unsubscribers conj unsubscribe))
+      (when-let [unsubscribe (js-call tts "onPlaybackReferenceTrackChange"
+                                      (fn [track]
+                                        (js-call transcription "setAgentAudioReferenceTrack" track)))]
+        (swap! unsubscribers conj unsubscribe))
+      #js {:start (fn [flow-generator]
+                    (when-not @disposed?
+                      (try
+                        (js-call tts "stop")
+                        (js-call transcription "stopListening")
+                        (reset! flow-atom (flow-generator))
+                        (dispatch! {:type "start"})
+                        (run-flow! nil false)
+                        (catch :default error
+                          (notify-error! error)))))
+           :stop (fn []
+                   (when-not @disposed?
+                     (clear-playback-unsub!)
+                     (reset! agent-speech-active? false)
+                     (reset! pending-interrupted-transcript nil)
+                     (js-call tts "stop")
+                     (stop-listening!)
+                     (js-call transcription "notifyAgentSpeechEnd")
+                     (stop-speaking-behaviors!)
+                     (dispatch! {:type "stop" :reason "manual"})
+                     (set-state! "idle")))
+           :getState (fn [] (clj->js @context))
+           :submitUserInput submit-user-input!
+           :addSubscriptionCleanup (fn [unsubscribe]
+                                     (swap! unsubscribers conj unsubscribe))
+           :receiveTranscript (fn [text is-final]
+                                (transcript-handler text is-final))
+           :receiveAudioInterruption interruption-handler
+           :dispose (fn []
+                      (when-not @disposed?
+                        (reset! disposed? true)
+                        (clear-playback-unsub!)
+                        (doseq [unsubscribe @unsubscribers]
+                          (unsubscribe))
+                        (reset! unsubscribers [])
+                        (reset! agent-speech-active? false)
+                        (reset! pending-interrupted-transcript nil)
+                        (js-call tts "stop")
+                        (js-call transcription "stopListening")
+                        (js-call transcription "notifyAgentSpeechEnd")
+                        (set-speaking! false)
+                        (set-listening! false)
+                        (js-call (prosodic) "stopTalking")
+                        (js-call agency "dispose")))})))
+
+(defn ConversationService
+  ([tts transcription] (create-service tts transcription nil nil))
+  ([tts transcription config] (create-service tts transcription config nil))
+  ([tts transcription config callbacks] (create-service tts transcription config callbacks)))
+
+(defn createConversationService
+  ([tts transcription] (ConversationService tts transcription nil nil))
+  ([tts transcription config] (ConversationService tts transcription config nil))
+  ([tts transcription config callbacks] (ConversationService tts transcription config callbacks)))

package/src/polymer/conversation/state.cljs

@@ -0,0 +1,186 @@
+(ns polymer.conversation.state
+  (:require [polymer.conversation.domain :as domain]))
+
+;; Conversation state is the pure local transcript and turn-taking ledger. Live
+;; provider handles stay in the agency's private effector; TTS and animation
+;; remain peer agencies reached through plain domain events.
+
+(def default-config
+  {:autoRespond true
+   :maxHistory 40
+   :responseSource "conversation"
+   :ttsAgency "tts"
+   :interruptionMode "cancel-agent"})
+
+(defn finite-number?
+  [value]
+  (and (number? value) (js/isFinite value)))
+
+(defn number-or
+  [value fallback]
+  (if (finite-number? value) value fallback))
+
+(defn clamp
+  [lo hi value]
+  (min hi (max lo value)))
+
+(defn normalize-config
+  [config]
+  (let [input (merge default-config (domain/data-map config))]
+    {:autoRespond (boolean (:autoRespond input))
+     :maxHistory (int (clamp 1 200 (number-or (:maxHistory input)
+                                              (:maxHistory default-config))))
+     :responseSource (domain/text-or (:responseSource input)
+                                     (:responseSource default-config))
+     :ttsAgency (domain/text-or (:ttsAgency input)
+                                (:ttsAgency default-config))
+     :interruptionMode (domain/text-or (:interruptionMode input)
+                                       (:interruptionMode default-config))}))
+
+(defn default-state
+  [config]
+  {:agency "conversation"
+   :status "idle"
+   :started false
+   :turnId nil
+   :history []
+   :context {}
+   :pendingResponse nil
+   :lastProviderError nil
+   :lastUserText nil
+   :lastAgentText nil
+   :lastEvent nil
+   :interrupted false
+   :startedCount 0
+   :stoppedCount 0
+   :userUtteranceCount 0
+   :agentUtteranceCount 0
+   :responseRequestCount 0
+   :ttsRequestCount 0
+   :cancelCount 0
+   :config (normalize-config config)})
+
+(defn config->state
+  [config]
+  (default-state config))
+
+(defn visible-state
+  [state]
+  (clj->js state))
+
+(defn configure
+  [state config]
+  (assoc state :config (normalize-config (merge (:config state)
+                                                (domain/data-map config)))))
+
+(defn reset-state
+  [state]
+  (default-state (:config state)))
+
+(defn append-history
+  [state entry]
+  (let [max-history (get-in state [:config :maxHistory])
+        history (conj (:history state) entry)]
+    (assoc state :history (vec (take-last max-history history)))))
+
+(defn next-turn-id
+  []
+  (str "conversation:" (.now js/Date) ":" (rand-int 1000000)))
+
+(defn mark-started
+  [state now-ms]
+  (-> state
+      (assoc :started true
+             :status "listening"
+             :turnId (or (:turnId state) (next-turn-id))
+             :interrupted false
+             :lastEvent {:type "conversation.status"
+                         :status "listening"
+                         :at now-ms})
+      (update :startedCount inc)))
+
+(defn mark-stopped
+  [state now-ms reason]
+  (-> state
+      (assoc :started false
+             :status "idle"
+             :pendingResponse nil
+             :lastEvent {:type "conversation.status"
+                         :status "idle"
+                         :reason reason
+                         :at now-ms})
+      (update :stoppedCount inc)))
+
+(defn record-user-utterance
+  [state text now-ms source]
+  (let [entry {:role "user"
+               :text text
+               :source source
+               :at now-ms
+               :turnId (:turnId state)}]
+    (-> state
+        (assoc :status "processing"
+               :lastUserText text
+               :lastEvent {:type "conversation.userUtterance"
+                           :text text
+                           :at now-ms})
+        (append-history entry)
+        (update :userUtteranceCount inc))))
+
+(defn record-response-request
+  [state request]
+  (-> state
+      (assoc :pendingResponse request
+             :lastProviderError nil
+             :lastEvent {:type "conversation.requestResponse"
+                         :requestId (:requestId request)
+                         :at (:requestedAt request)})
+      (update :responseRequestCount inc)))
+
+(defn record-provider-error
+  [state request-id message now-ms]
+  (-> state
+      (assoc :status "listening"
+             :pendingResponse nil
+             :lastProviderError message
+             :lastEvent {:type "conversation.providerError"
+                         :requestId request-id
+                         :message message
+                         :at now-ms})))
+
+(defn record-agent-utterance
+  [state text now-ms source]
+  (let [entry {:role "agent"
+               :text text
+               :source source
+               :at now-ms
+               :turnId (:turnId state)}]
+    (-> state
+        (assoc :status "agentSpeaking"
+               :pendingResponse nil
+               :lastProviderError nil
+               :lastAgentText text
+               :lastEvent {:type "conversation.agentUtterance"
+                           :text text
+                           :at now-ms})
+        (append-history entry)
+        (update :agentUtteranceCount inc))))
+
+(defn record-tts-request
+  [state request]
+  (-> state
+      (assoc :lastEvent {:type "tts.requestSpeak"
+                         :requestId (:requestId request)
+                         :at (:requestedAt request)})
+      (update :ttsRequestCount inc)))
+
+(defn record-cancel
+  [state now-ms reason]
+  (-> state
+      (assoc :status "interrupted"
+             :pendingResponse nil
+             :interrupted true
+             :lastEvent {:type "conversation.cancelRequested"
+                         :reason reason
+                         :at now-ms})
+      (update :cancelCount inc)))

package/src/polymer/core.cljs

@@ -0,0 +1,172 @@
+(ns polymer.core
+  (:require [polymer.animation.agency :as animation]
+            [polymer.animation.service :as animation-service]
+            [polymer.blink.agency :as blink]
+            [polymer.camera-context.agency :as camera-context]
+            [polymer.character :as character]
+            [polymer.conversation.agency :as conversation]
+            [polymer.conversation.service :as conversation-service]
+            [polymer.eye-head.agency :as eye-head]
+            [polymer.eye-head.service :as eye-head-service]
+            [polymer.gesture.agency :as gesture]
+            [polymer.gaze.agency :as gaze]
+            [polymer.tts.agency :as tts]
+            [polymer.lipsync.agency :as lipsync]
+            [polymer.prosodic.agency :as prosodic]
+            [polymer.transcription.agency :as transcription]
+            [polymer.transcription.service :as transcription-service]
+            [polymer.society :as society]))
+
+(def DEFAULT_AGENCY_SOCIETY society/DEFAULT_AGENCY_SOCIETY)
+
+;; Public JavaScript entry points.
+;;
+;; Polymer is authored in CLJS, but LoomLarge imports the compiled package from
+;; JavaScript/TypeScript. The exports stay agency-oriented: LoomLarge can create
+;; a character agency network, but Polymer owns the cross-agency routing and
+;; Animation owns the Embody runtime calls.
+
+(defn createBlinkAgency
+  "Create the Blink agency directly. Use createCharacterAgencies when Blink
+  should route animation intent to Polymer Animation."
+  ([] (blink/create-blink-agency nil))
+  ([config] (blink/create-blink-agency config)))
+
+(defn createAnimationAgency
+  "Create the Animation agency directly. Pass an Embody runtime or engine in
+  config when the agency should execute snippets."
+  ([] (animation/create-animation-agency nil))
+  ([config] (animation/create-animation-agency config)))
+
+(defn createAnimationService
+  "Create the JS compatibility animation API backed by Polymer Animation.
+  LoomLarge uses this while it is still calling the historical animation manager
+  shape; snippets still enter Polymer's agency-local planner and scheduler."
+  [engine]
+  (animation-service/createAnimationService engine))
+
+(defn createEyeHeadTrackingService
+  "Create the JS compatibility Eye/Head Tracking API backed by Polymer
+  Eye/Head. Accepted movement requests route through Polymer Animation."
+  ([] (eye-head-service/createEyeHeadTrackingService nil nil))
+  ([config] (eye-head-service/createEyeHeadTrackingService config nil))
+  ([config callbacks] (eye-head-service/createEyeHeadTrackingService config callbacks)))
+
+(defn createTranscriptionService
+  "Create the JS compatibility transcription API backed by Polymer
+  Transcription. Browser SpeechRecognition is owned inside this package."
+  ([] (transcription-service/createTranscriptionService nil nil))
+  ([config] (transcription-service/createTranscriptionService config nil))
+  ([config callbacks] (transcription-service/createTranscriptionService config callbacks)))
+
+(defn createConversationService
+  "Create the JS compatibility conversation API backed by Polymer
+  Conversation."
+  ([tts transcription] (conversation-service/createConversationService tts transcription nil nil))
+  ([tts transcription config] (conversation-service/createConversationService tts transcription config nil))
+  ([tts transcription config callbacks] (conversation-service/createConversationService tts transcription config callbacks)))
+
+(def TranscriptionService transcription-service/TranscriptionService)
+(def ConversationService conversation-service/ConversationService)
+(def DEFAULT_EYE_HEAD_CONFIG eye-head-service/DEFAULT_EYE_HEAD_CONFIG)
+(def DEFAULT_ANIMATION_KEYS eye-head-service/DEFAULT_ANIMATION_KEYS)
+(def EYE_AUS eye-head-service/EYE_AUS)
+(def HEAD_AUS eye-head-service/HEAD_AUS)
+
+(def animationEventEmitter animation-service/animationEventEmitter)
+(def snippetList$ animation-service/snippetList$)
+(def globalPlaybackState$ animation-service/globalPlaybackState$)
+(def bakedClipList$ animation-service/bakedClipList$)
+(def playingBakedAnimations$ animation-service/playingBakedAnimations$)
+(def bakedAnimationProgress$ animation-service/bakedAnimationProgress$)
+
+(defn snippetState$ [snippet-name]
+  (animation-service/snippetState$ snippet-name))
+
+(defn snippetTime$ [snippet-name]
+  (animation-service/snippetTime$ snippet-name))
+
+(defn bakedAnimationState$ [clip-name]
+  (animation-service/bakedAnimationState$ clip-name))
+
+(defn getBundledSnippetNames [list-key]
+  (animation-service/getBundledSnippetNames list-key))
+
+(defn getStoredSnippetNames
+  ([list-key] (animation-service/getStoredSnippetNames list-key))
+  ([list-key storage] (animation-service/getStoredSnippetNames list-key storage)))
+
+(defn getAvailableSnippetNames
+  ([list-key] (animation-service/getAvailableSnippetNames list-key))
+  ([list-key storage] (animation-service/getAvailableSnippetNames list-key storage)))
+
+(defn resolveSnippetEntry
+  ([list-key name] (animation-service/resolveSnippetEntry list-key name))
+  ([list-key name storage] (animation-service/resolveSnippetEntry list-key name storage)))
+
+(defn preloadAllSnippets []
+  (animation-service/preloadAllSnippets))
+
+(defn clearPreloadedSnippets
+  ([] (animation-service/clearPreloadedSnippets))
+  ([storage] (animation-service/clearPreloadedSnippets storage)))
+
+(defn createGazeAgency
+  "Create the Gaze agency directly. Use createCharacterAgencies when Gaze
+  should participate in the per-character agency network."
+  ([] (gaze/create-gaze-agency nil))
+  ([config] (gaze/create-gaze-agency config)))
+
+(defn createEyeHeadTrackingAgency
+  "Create the Eye/Head Tracking agency directly."
+  ([] (eye-head/create-eye-head-tracking-agency nil))
+  ([config] (eye-head/create-eye-head-tracking-agency config)))
+
+(defn createLipSyncAgency
+  "Create the LipSync agency directly. Use createCharacterAgencies when
+  LipSync should route viseme animation intent to Polymer Animation."
+  ([] (lipsync/create-lipsync-agency nil))
+  ([config] (lipsync/create-lipsync-agency config))
+  ([config runtime] (lipsync/create-lipsync-agency config runtime)))
+
+(defn createTTSAgency
+  "Create the TTS agency directly. Use createCharacterAgencies when TTS should
+  route speech timing facts into Polymer LipSync."
+  ([] (tts/create-tts-agency nil))
+  ([config] (tts/create-tts-agency config)))
+
+(defn createGestureAgency
+  "Create the Gesture agency directly. Use createCharacterAgencies when Gesture
+  should route arm/hand animation intent to Polymer Animation."
+  ([] (gesture/create-gesture-agency nil))
+  ([config] (gesture/create-gesture-agency config)))
+
+(defn createProsodicAgency
+  "Create the Prosodic Expression agency directly. Use createCharacterAgencies
+  when speech and blink facts should route to prosody inside Polymer."
+  ([] (prosodic/create-prosodic-agency nil))
+  ([config] (prosodic/create-prosodic-agency config)))
+
+(defn createConversationAgency
+  "Create the Conversation agency directly. Use createCharacterAgencies when
+  transcript facts should route into Conversation and Conversation speech
+  requests should route to TTS inside Polymer."
+  ([] (conversation/create-conversation-agency nil))
+  ([config] (conversation/create-conversation-agency config)))
+
+(defn createTranscriptionAgency
+  "Create the Transcription agency directly. Use createCharacterAgencies when
+  final transcript facts should route to Conversation inside Polymer."
+  ([] (transcription/create-transcription-agency nil))
+  ([config] (transcription/create-transcription-agency config)))
+
+(defn createCameraContextAgency
+  "Create the Camera Context agency directly. Use createCharacterAgencies when
+  camera-relative facts should route to Gaze inside Polymer."
+  ([] (camera-context/create-camera-context-agency nil))
+  ([config] (camera-context/create-camera-context-agency config)))
+
+(defn createCharacterAgencies
+  "Create the per-character Polymer agency network."
+  ([] (character/create-character-agencies nil))
+  ([config] (character/create-character-agencies config)))