prompt_objects 0.6.0 → 0.7.0

data/templates/music-pro/objects/sonic_pi.md

@@ -0,0 +1,35 @@
+---
+name: sonic_pi
+description: Connection engineer — starts, queries, and troubleshoots the external Sonic Pi live engine
+tools:
+  - query_music_engine
+  - read_file
+  - list_files
+---
+
+# Sonic Pi Connection Engineer
+
+You manage the sound-engine connection, not the composition.
+
+When asked to connect, call `query_music_engine`. If it does not respond, tell the human to:
+
+1. Open Sonic Pi.
+2. Enable incoming OSC if Sonic Pi asks for it.
+3. In an empty buffer run this one line, substituting the environment's absolute path:
+
+   `run_file "/absolute/path/to/the/environment/extras/sonic_pi_boot.rb"`
+
+4. Press Run, then ask you to check again.
+
+The usual installed path is `~/.prompt_objects/environments/<environment-name>/extras/sonic_pi_boot.rb`. Prefer `run_file` to pasting the script because Sonic Pi buffers have size limits.
+
+When connected, summarize tempo, active voices, live patterns, patches, transforms, and cycles. A successful query proves that OSC works in both directions. Do not claim that state proves the music sounds good: agents cannot hear Sonic Pi. Invite specific human listening feedback and relay it to the conductor.
+
+Connection is not playback. A response with `connected: true` but an empty
+`voices` object means the engine is loaded and silent. Never describe a pattern
+stored in env_data or written in prose as sounding. Only active voice state from
+`query_music_engine` proves that a musician's playback tool reached Sonic Pi.
+Refer a silent-but-connected composition back to `conductor` with instructions
+to require immediate `set_live_pattern` calls and verify each voice.
+
+If the engine stops responding, have the human run the same `run_file` line again. Existing live patterns then need to be sent again.

data/templates/music-pro/objects/voice_harmony.md

@@ -0,0 +1,48 @@
+---
+name: voice_harmony
+description: Harmonic musician — owns the voicing, harmonic motion, and sustained tonal field
+tools:
+  - set_live_pattern
+  - define_patch
+  - trigger_event
+  - stop_voice
+---
+
+# Voice: Harmony
+
+You are an independent harmonic musician. Read `composition` before playing. Own one live voice named `harmony`; only you rewrite it.
+
+## Performance contract
+
+When asked to start, join, activate, or revise your part, perform the change in
+that same turn. On first activation you MUST call `set_live_pattern` before
+responding. If you invent a patch, call `define_patch` first and then activate
+that patch with `set_live_pattern`; `define_patch` alone makes no sound. On
+later changes, call every playback tool needed to make the requested change
+real. Do not merely draft notation, ask “shall I activate this?”, or wait for
+confirmation: the conductor's request is authorization. Save state only after
+the playback calls return without an error, and report the calls you actually
+completed.
+
+Interpret the contract rather than merely spelling every root-position chord.
+Use voice leading, inversions, common tones, register, rests, and harmonic rhythm
+deliberately. You are the default continuity anchor: cover the contract's full
+harmonic cycle and keep adjacent sustained events connected unless the conductor
+assigns continuity to another voice. A long step is not permission for a short
+sound followed by dead air; default duration-aware gating handles this, and an
+explicit `gate` slightly longer than the step can create deliberate overlap.
+Listen structurally to the other POs through their env_data: leave spectral and
+rhythmic room instead of filling every beat. When directed to evolve, preserve at
+least one audible relationship from your prior pattern.
+
+Start with a named patch such as `air_blade` or `soft_rodeo`, or use `define_patch` to invent a timbre. Named patches are examples, not restrictions. Keep initial mix amp around 0.35. Write your exact pattern, patch, intent, register, and relationship to `voice_harmony_state` after each submitted playback change.
+
+Useful notation:
+
+- `(D3,A3,C4,E4)/8{gate=8.4}` — an eight-beat chord with gentle overlap
+- `~/4` — four beats of explicit silence
+- `[(D3,A3,C4)/2 (G3,B3,E4)/2]/4` — a subdivision stretched to four beats
+- `<(D3,A3,C4) (G3,B3,E4)>/8` — alternate voicings each cycle
+- `{amp=0.7,pan=-0.15,cutoff=68}` — per-event controls
+
+Use transforms for longer-form variation, for example `every: {cycles: 4, transform: "reverse"}` or a small transpose/rotation. Avoid rapid dense chords unless the contract explicitly calls for them.

data/templates/music-pro/objects/voice_rhythm.md

@@ -0,0 +1,43 @@
+---
+name: voice_rhythm
+description: Rhythmic musician — owns pulse, percussion, silence, and the ensemble's changing sense of time
+tools:
+  - set_live_pattern
+  - define_patch
+  - trigger_event
+  - stop_voice
+---
+
+# Voice: Rhythm
+
+You are an independent rhythm musician. Read `composition` and the other voice states before playing. Own one live voice named `rhythm`; only you rewrite it.
+
+## Performance contract
+
+When asked to start, join, activate, or revise your part, perform the change in
+that same turn. On first activation you MUST call `set_live_pattern` before
+responding. If you invent a patch, call `define_patch` first and then activate
+that patch with `set_live_pattern`; `define_patch` alone makes no sound. On
+later changes, call every playback tool needed to make the requested change
+real. Do not merely draft notation, ask “shall I activate this?”, or wait for
+confirmation: the conductor's request is authorization. Save state only after
+the playback calls return without an error, and report the calls you actually
+completed. If the correct musical choice is silence, call `stop_voice` rather
+than merely saying you will remain silent.
+
+Rhythm includes silence. Establish a legible pulse or counter-pulse that serves
+the current music, then develop it gradually. If you own the connective layer,
+keep the meter inferable and avoid gaps longer than two beats; quiet events are
+usually better than vanishing. If harmony or texture already carries motion,
+you may answer it more sparsely. Do not default to a constant kick-and-hat loop.
+Patterns may contain built-in samples such as `@bd_haus/0.5` or pitched synth
+events; per-event sample names let one voice combine different percussion
+sounds. Use explicit rests to place them.
+
+Example syntax (illustrative, never a mandatory groove):
+
+`@bd_haus/0.5{amp=0.35} ~/1.5 @elec_tick/0.25{amp=0.18,pan=0.2} ~/1.75`
+
+Create a raw sample patch when you want shared defaults and effects, or use event samples directly. Keep initial mix amp around 0.3. Probability and `every` transformations can create deterministic variation; always seed them and preserve the beat's identity. Write pattern, sources, intent, density, and relationship to `voice_rhythm_state` after every submitted playback rewrite.
+
+If the human is speaking or asks for background music, favor low density and unaccented events. If the contract asks for foreground experimental music, you have much more freedom—but still coordinate with the ensemble.

data/templates/music-pro/objects/voice_texture.md

@@ -0,0 +1,42 @@
+---
+name: voice_texture
+description: Texture musician — owns motifs, counterpoint, timbral gestures, and the surprising edge of the composition
+tools:
+  - set_live_pattern
+  - define_patch
+  - trigger_event
+  - stop_voice
+---
+
+# Voice: Texture
+
+You are an independent texture and motif musician. Read `composition`, `voice_harmony_state`, and `voice_rhythm_state` before playing. Own one live voice named `texture`; only you rewrite it.
+
+## Performance contract
+
+When asked to start, join, activate, or revise your part, perform the change in
+that same turn. On first activation you MUST call `set_live_pattern` before
+responding. If you invent a patch, call `define_patch` first and then activate
+that patch with `set_live_pattern`; `define_patch` alone makes no sound. On
+later changes, call every playback tool needed to make the requested change
+real. Do not merely draft notation, ask “shall I activate this?”, or wait for
+confirmation: the conductor's request is authorization. Save state only after
+the playback calls return without an error, and report the calls you actually
+completed.
+
+Find a small identity—a two- or three-note contour, a sample gesture, an unusual
+articulation, or a timbral motion—and develop it through recurrence and
+transformation. When you are a foreground motif, build a connected 8- or
+16-beat phrase from recurring cells rather than one isolated note followed by a
+giant rest. When you are color around another connective voice, sparse gestures
+are welcome. Your purpose is meaningful surprise, not constant decoration. Use
+rests deliberately and avoid occupying the harmony's register continuously.
+
+The surface is open-ended. Start from `tiny_kalimba`, `chip_raw`, or a runtime patch, and change raw synth/effect parameters when that serves the idea. Examples:
+
+- `C5/0.5 E5/0.5 ~/3` — a tiny motif with space
+- `<C5 D5 G4>/0.5 ~/3.5` — one alternating note per cycle
+- `[C5/1 E5/1 G5/1]/1 ~/3` — compressed subdivision
+- `@ambi_glass_hum/1{amp=0.2,pan=0.4} ~/7` — a sparse sample gesture
+
+Keep initial mix amp around 0.25. Use a deterministic seed for probability. After a submitted playback rewrite, store the pattern, patch, motif identity, register, and reason for the change in `voice_texture_state`.

data/templates/music-pro/primitives/define_patch.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require "json"
+require_relative "support/osc_bridge"
+require_relative "support/music_protocol"
+
+module PromptObjects
+  module Primitives
+    class DefinePatch < Primitive
+      execution_policy parallel_safe: true, side_effect: :write, resource_keys: ->(arguments, _context, _capability) {
+        ["music:patch:#{arguments[:name] || arguments['name']}"]
+      }
+
+      def name
+        "define_patch"
+      end
+
+      def description
+        "Define or replace a reusable Sonic Pi patch at runtime. A patch can name any Sonic Pi synth or built-in sample, set raw parameters, and add up to three raw effects."
+      end
+
+      def parameters
+        {
+          type: "object",
+          properties: {
+            name: { type: "string", description: "Patch name used by set_live_pattern" },
+            patch: {
+              type: "object",
+              description: "{kind: 'synth', synth: 'blade', params: {...}, effects: [{name: 'reverb', params: {...}}]} or a sample equivalent"
+            }
+          },
+          required: %w[name patch]
+        }
+      end
+
+      def receive(message, context:)
+        name = MusicProtocol.patch_name!(message[:name] || message["name"])
+        patch = MusicProtocol.patch!(message[:patch] || message["patch"])
+        OscBridge.send_message("/prompt_objects/music/patch", name, JSON.generate(patch))
+        "Defined live patch #{name} (#{patch['kind'] || 'synth'}: #{patch['synth'] || patch['sample']})"
+      rescue => e
+        "Error defining patch: #{e.message}. Is Sonic Pi running the music-pro boot script?"
+      end
+    end
+  end
+end

data/templates/music-pro/primitives/query_music_engine.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require "json"
+require "socket"
+require_relative "support/osc_bridge"
+
+module PromptObjects
+  module Primitives
+    class QueryMusicEngine < Primitive
+      execution_policy parallel_safe: true, side_effect: :read
+
+      TIMEOUT = 2
+
+      def name = "query_music_engine"
+
+      def description
+        "Read the live state reported by Sonic Pi: tempo, safety limits, available patch names, and every voice's active pattern, patch summary, transforms, and cycle count."
+      end
+
+      def parameters
+        { type: "object", properties: {}, required: [] }
+      end
+
+      def receive(message, context:)
+        socket = UDPSocket.new
+        socket.bind("127.0.0.1", 0)
+        response_port = socket.addr[1]
+        OscBridge.send_message("/prompt_objects/music/query", response_port)
+
+        unless IO.select([socket], nil, nil, TIMEOUT)
+          return "Sonic Pi is not responding. Run extras/sonic_pi_boot.rb in Sonic Pi and try again."
+        end
+
+        data, = socket.recvfrom(65_535)
+        payload = parse_osc_string(data)
+        state = JSON.parse(payload)
+        JSON.pretty_generate(state)
+      rescue JSON::ParserError => e
+        "Sonic Pi returned invalid state: #{e.message}"
+      rescue => e
+        "Error querying music engine: #{e.message}"
+      ensure
+        socket&.close
+      end
+
+      private
+
+      def parse_osc_string(data)
+        raise "empty OSC response" if data.nil? || data.empty?
+
+        address_end = data.index("\x00") or raise "malformed OSC address"
+        pos = padded_position(address_end + 1)
+        raise "OSC response has no string argument" unless data[pos] == ","
+
+        type_end = data.index("\x00", pos) or raise "malformed OSC type tag"
+        raise "OSC response is not a string" unless data[(pos + 1)...type_end].start_with?("s")
+
+        pos = padded_position(type_end + 1)
+        string_end = data.index("\x00", pos) or raise "malformed OSC string"
+        data[pos...string_end]
+      end
+
+      def padded_position(pos)
+        pos += 1 while (pos % 4) != 0
+        pos
+      end
+    end
+  end
+end

data/templates/music-pro/primitives/set_live_pattern.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require "json"
+require_relative "support/osc_bridge"
+require_relative "support/music_protocol"
+
+module PromptObjects
+  module Primitives
+    class SetLivePattern < Primitive
+      execution_policy parallel_safe: true, side_effect: :write, resource_keys: ->(arguments, _context, _capability) {
+        ["music:voice:#{arguments[:voice] || arguments['voice']}"]
+      }
+
+      def name
+        "set_live_pattern"
+      end
+
+      def description
+        "Create or atomically rewrite a named live voice pattern. Supports notes, chords, rests, samples, subdivisions, alternation, repetition, per-event controls, and cycle transforms. The new definition starts on the next bar."
+      end
+
+      def parameters
+        {
+          type: "object",
+          properties: {
+            voice: { type: "string", description: "Stable voice name owned by this Prompt Object" },
+            pattern: {
+              type: "string",
+              description: "Pattern notation: C4/1, (C4,E4,G4)/2 chord, ~/1 rest, @bd_haus/0.5 sample, [C4/0.5 E4/0.5]/1 subdivision, <C4 E4 G4>/1 cycle alternation, and *3 repetition. Duration sets the next onset and defaults synth gate near that length; use {gate=1.2} for overlap or articulation, alongside amp, pan, cutoff, or probability."
+            },
+            patch: {
+              description: "Named patch, or inline patch object with kind, synth/sample, params, and up to three effects",
+              oneOf: [{ type: "string" }, { type: "object" }]
+            },
+            transforms: {
+              type: "object",
+              description: "Optional transpose, stretch, rotate, reverse, probability, seed, or every-cycle transform"
+            },
+            mix: {
+              type: "object",
+              description: "Voice amp and pan. Final amplitude is stage-clamped by the engine."
+            }
+          },
+          required: %w[voice pattern]
+        }
+      end
+
+      def receive(message, context:)
+        voice = MusicProtocol.voice!(message[:voice] || message["voice"])
+        pattern = MusicProtocol.pattern!(message[:pattern] || message["pattern"])
+        patch = message[:patch] || message["patch"] || "soft_rodeo"
+        patch = patch.is_a?(Hash) ? MusicProtocol.patch!(patch) : MusicProtocol.patch_name!(patch)
+        transforms = MusicProtocol.transforms!(message[:transforms] || message["transforms"])
+        mix = MusicProtocol.mix!(message[:mix] || message["mix"])
+
+        definition = {
+          voice: voice,
+          pattern: pattern,
+          patch: patch,
+          transforms: transforms,
+          mix: mix
+        }
+        OscBridge.send_message("/prompt_objects/music/pattern", JSON.generate(definition))
+        "Queued #{voice} for the next bar: #{pattern}"
+      rescue => e
+        "Error setting live pattern: #{e.message}. Is Sonic Pi running the music-pro boot script?"
+      end
+    end
+  end
+end

data/templates/music-pro/primitives/set_tempo.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require_relative "support/osc_bridge"
+
+module PromptObjects
+  module Primitives
+    class SetTempo < Primitive
+      execution_policy parallel_safe: false, side_effect: :exclusive
+
+      def name = "set_tempo"
+
+      def description
+        "Set the shared live-engine tempo. Values are stage-bounded to 30-240 BPM."
+      end
+
+      def parameters
+        { type: "object", properties: { bpm: { type: "number", description: "Tempo from 30 through 240 BPM" } }, required: ["bpm"] }
+      end
+
+      def receive(message, context:)
+        bpm = (message[:bpm] || message["bpm"]).to_f
+        return "Error: bpm must be between 30 and 240" unless bpm.between?(30, 240)
+
+        OscBridge.send_message("/prompt_objects/music/tempo", bpm)
+        "Tempo queued at #{bpm} BPM"
+      rescue => e
+        "Error setting tempo: #{e.message}. Is Sonic Pi running the music-pro boot script?"
+      end
+    end
+  end
+end

data/templates/music-pro/primitives/stop_voice.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require_relative "support/osc_bridge"
+require_relative "support/music_protocol"
+
+module PromptObjects
+  module Primitives
+    class StopVoice < Primitive
+      execution_policy parallel_safe: false, side_effect: :exclusive
+
+      def name = "stop_voice"
+
+      def description
+        "Mute a named live voice on the next bar, or use all for the emergency master stop."
+      end
+
+      def parameters
+        { type: "object", properties: { voice: { type: "string", description: "Voice name or all" } }, required: ["voice"] }
+      end
+
+      def receive(message, context:)
+        raw = (message[:voice] || message["voice"]).to_s
+        voice = raw == "all" ? raw : MusicProtocol.voice!(raw)
+        OscBridge.send_message("/prompt_objects/music/stop", voice)
+        voice == "all" ? "Emergency stop sent for all voices" : "Queued mute for #{voice}"
+      rescue => e
+        "Error stopping voice: #{e.message}. Is Sonic Pi running the music-pro boot script?"
+      end
+    end
+  end
+end

data/templates/music-pro/primitives/support/music_protocol.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+require "json"
+
+module PromptObjects
+  module Primitives
+    # Validation and serialization shared by the live-music tools. Sonic Pi is
+    # deliberately permissive about timbre, while this boundary keeps malformed
+    # or accidentally enormous agent messages away from the stage audio engine.
+    module MusicProtocol
+      MAX_PATTERN_BYTES = 4096
+      MAX_PATCH_BYTES = 8192
+      MAX_EFFECTS = 3
+      MAX_PARAMS = 24
+      VOICE_NAME = /\A[a-zA-Z][a-zA-Z0-9_-]{0,39}\z/
+      PATCH_NAME = /\A[a-zA-Z][a-zA-Z0-9_-]{0,39}\z/
+
+      module_function
+
+      def voice!(value)
+        value = value.to_s
+        raise ArgumentError, "voice must be 1-40 letters, numbers, underscores, or hyphens" unless VOICE_NAME.match?(value)
+
+        value
+      end
+
+      def pattern!(value)
+        value = value.to_s.strip
+        raise ArgumentError, "pattern cannot be empty" if value.empty?
+        raise ArgumentError, "pattern exceeds #{MAX_PATTERN_BYTES} bytes" if value.bytesize > MAX_PATTERN_BYTES
+        raise ArgumentError, "pattern has unbalanced delimiters" unless balanced?(value)
+
+        value
+      end
+
+      def patch_name!(value)
+        value = value.to_s
+        raise ArgumentError, "patch name must be 1-40 letters, numbers, underscores, or hyphens" unless PATCH_NAME.match?(value)
+
+        value
+      end
+
+      def patch!(value)
+        patch = stringify_keys(value || {})
+        raise ArgumentError, "patch must be an object" unless patch.is_a?(Hash)
+
+        kind = patch.fetch("kind", "synth")
+        raise ArgumentError, "patch kind must be synth or sample" unless %w[synth sample].include?(kind)
+
+        source_key = kind == "sample" ? "sample" : "synth"
+        source = patch[source_key]
+        raise ArgumentError, "#{kind} patch requires #{source_key}" if source.to_s.empty?
+        validate_identifier!(source, "synth/sample")
+
+        params = patch.fetch("params", {})
+        raise ArgumentError, "patch params must be an object" unless params.is_a?(Hash)
+        raise ArgumentError, "patch has too many params (max #{MAX_PARAMS})" if params.length > MAX_PARAMS
+        params.each { |key, val| validate_param!(key, val) }
+
+        effects = patch.fetch("effects", [])
+        raise ArgumentError, "patch effects must be an array" unless effects.is_a?(Array)
+        raise ArgumentError, "patch has too many effects (max #{MAX_EFFECTS})" if effects.length > MAX_EFFECTS
+        effects.each do |effect|
+          raise ArgumentError, "each effect must be an object" unless effect.is_a?(Hash)
+          validate_identifier!(effect["name"], "effect")
+          effect_params = effect.fetch("params", {})
+          raise ArgumentError, "effect params must be an object" unless effect_params.is_a?(Hash)
+          raise ArgumentError, "effect has too many params (max #{MAX_PARAMS})" if effect_params.length > MAX_PARAMS
+          effect_params.each { |key, val| validate_param!(key, val) }
+        end
+
+        encoded = JSON.generate(patch)
+        raise ArgumentError, "patch exceeds #{MAX_PATCH_BYTES} bytes" if encoded.bytesize > MAX_PATCH_BYTES
+
+        patch
+      end
+
+      def transforms!(value)
+        transforms = stringify_keys(value || {})
+        raise ArgumentError, "transforms must be an object" unless transforms.is_a?(Hash)
+
+        allowed = %w[transpose stretch rotate reverse probability seed every]
+        unknown = transforms.keys - allowed
+        raise ArgumentError, "unknown transforms: #{unknown.join(', ')}" unless unknown.empty?
+
+        transforms
+      end
+
+      def mix!(value)
+        mix = stringify_keys(value || {})
+        raise ArgumentError, "mix must be an object" unless mix.is_a?(Hash)
+
+        unknown = mix.keys - %w[amp pan]
+        raise ArgumentError, "unknown mix keys: #{unknown.join(', ')}" unless unknown.empty?
+
+        mix
+      end
+
+      def stringify_keys(value)
+        case value
+        when Hash
+          value.each_with_object({}) { |(key, val), out| out[key.to_s] = stringify_keys(val) }
+        when Array
+          value.map { |item| stringify_keys(item) }
+        else
+          value
+        end
+      end
+
+      def balanced?(text)
+        pairs = { "]" => "[", ")" => "(", ">" => "<", "}" => "{" }
+        stack = []
+        text.each_char do |char|
+          stack << char if pairs.value?(char)
+          return false if pairs.key?(char) && stack.pop != pairs[char]
+        end
+        stack.empty?
+      end
+
+      def validate_identifier!(value, label)
+        str = value.to_s
+        valid = str.match?(/\A[a-zA-Z][a-zA-Z0-9_:-]{0,79}\z/)
+        raise ArgumentError, "invalid #{label} name" unless valid
+      end
+
+      def validate_param!(key, value)
+        validate_identifier!(key, "parameter")
+        return if value.is_a?(Numeric) || value == true || value == false || value.nil?
+        return if value.is_a?(String) && value.bytesize <= 160
+        return if value.is_a?(Array) && value.length <= 16 && value.all? { |item| item.is_a?(Numeric) }
+
+        raise ArgumentError, "unsupported value for parameter #{key}"
+      end
+    end
+  end
+end

data/templates/music-pro/primitives/support/osc_bridge.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require "osc-ruby"
+
+module PromptObjects
+  module Primitives
+    # Shared OSC client for communicating with Sonic Pi.
+    # Thread-safe via Mutex. Used by music primitives and the heartbeat service.
+    module OscBridge
+      SONIC_PI_HOST = ENV.fetch("SONIC_PI_HOST", "127.0.0.1")
+      SONIC_PI_PORT = ENV.fetch("SONIC_PI_PORT", "4560").to_i
+
+      @client = nil
+      @mutex = Mutex.new
+
+      def self.client
+        @mutex.synchronize do
+          @client ||= OSC::Client.new(SONIC_PI_HOST, SONIC_PI_PORT)
+        end
+      end
+
+      def self.send_message(path, *args)
+        client.send(OSC::Message.new(path, *args))
+      end
+
+      def self.connected?
+        !@client.nil?
+      rescue
+        false
+      end
+    end
+  end
+end

data/templates/music-pro/primitives/trigger_event.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require "json"
+require_relative "support/osc_bridge"
+require_relative "support/music_protocol"
+
+module PromptObjects
+  module Primitives
+    class TriggerEvent < Primitive
+      execution_policy parallel_safe: true, side_effect: :write, resource_keys: ->(arguments, _context, _capability) {
+        ["music:voice:#{arguments[:voice] || arguments['voice']}"]
+      }
+
+      def name = "trigger_event"
+
+      def description
+        "Trigger one bounded, immediate note, chord, or built-in sample for an accent. Use set_live_pattern for the composition itself."
+      end
+
+      def parameters
+        {
+          type: "object",
+          properties: {
+            voice: { type: "string" },
+            event: { type: "string", description: "One event such as C4/1, (C4,E4,G4)/2, or @elec_blip/0.25{amp=0.3}" },
+            patch: { oneOf: [{ type: "string" }, { type: "object" }] }
+          },
+          required: %w[voice event]
+        }
+      end
+
+      def receive(message, context:)
+        voice = MusicProtocol.voice!(message[:voice] || message["voice"])
+        event = MusicProtocol.pattern!(message[:event] || message["event"])
+        patch = message[:patch] || message["patch"] || "soft_rodeo"
+        patch = patch.is_a?(Hash) ? MusicProtocol.patch!(patch) : MusicProtocol.patch_name!(patch)
+        OscBridge.send_message("/prompt_objects/music/trigger", JSON.generate({ voice: voice, pattern: event, patch: patch }))
+        "Triggered #{event} on #{voice}"
+      rescue => e
+        "Error triggering event: #{e.message}. Is Sonic Pi running the music-pro boot script?"
+      end
+    end
+  end
+end

data/templates/music-pro/vendor/osc-ruby-1.1.5/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2009 Colin Harris
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the Software is
+ furnished to do so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in
+ all copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ THE SOFTWARE.