ag-ui 0.3.0 → 1.0.0

data/lib/ag_ui/middleware/state.rb

@@ -39,49 +39,49 @@ module AgUi
     # The frontend applies the same snapshot/patch to its own store; env[:state]
     # is kept coherent so the agent's own later reads (and further deltas) see
     # the current value.
-    class State
+    class State < Brute::Middleware::Base
       SNAPSHOT_TOOL = "AGUISendStateSnapshot"
       DELTA_TOOL    = "AGUISendStateDelta"
       TOOL_NAMES    = [SNAPSHOT_TOOL, DELTA_TOOL].freeze
 
       SNAPSHOT_DEFINITION = {
-        "name" => SNAPSHOT_TOOL,
+        "name"        => SNAPSHOT_TOOL,
         "description" =>
-          "Replace the shared application state with a new snapshot; the " \
+                         "Replace the shared application state with a new snapshot; the " \
           "frontend re-renders from it. Send the COMPLETE next state object, " \
           "not a diff. Prefer AGUISendStateDelta for small targeted changes.",
-        "parameters" => {
-          "type" => "object",
+        "parameters"  => {
+          "type"       => "object",
           "properties" => {
             "snapshot" => {
-              "type" => "object",
+              "type"        => "object",
               "description" => "The complete new application state.",
             },
           },
-          "required" => %w[snapshot],
+          "required"   => %w[snapshot],
         },
       }.freeze
 
       DELTA_DEFINITION = {
-        "name" => DELTA_TOOL,
+        "name"        => DELTA_TOOL,
         "description" =>
-          "Apply a JSON Patch (RFC 6902) to the shared application state — an " \
+                         "Apply a JSON Patch (RFC 6902) to the shared application state — an " \
           "array of {op, path, value} operations. Use for small, targeted " \
           "changes. Paths are JSON Pointers, e.g. " \
           "\"/documentEditor/activeTabId\". ops: add, replace, remove, move, " \
           "copy, test.",
-        "parameters" => {
-          "type" => "object",
+        "parameters"  => {
+          "type"       => "object",
           "properties" => {
             "delta" => {
-              "type" => "array",
+              "type"        => "array",
               "description" =>
-                "JSON Patch operations, e.g. " \
+                               "JSON Patch operations, e.g. " \
                 "[{\"op\":\"replace\",\"path\":\"/theme\",\"value\":\"dark\"}].",
-              "items" => { "type" => "object" },
+              "items"       => { "type" => "object" },
             },
           },
-          "required" => %w[delta],
+          "required"   => %w[delta],
         },
       }.freeze
 
@@ -153,7 +153,7 @@ module AgUi
           snapshot = tool_call.arguments["snapshot"]
           if snapshot.is_a?(Hash)
             env[:state] = snapshot
-            env[:events] << { type: :state_snapshot, data: { snapshot: snapshot } }
+            env.emit(:state_snapshot, { snapshot: snapshot })
             ack(env, tool_call)
           else
             ack(env, tool_call, error: "snapshot must be an object")
@@ -178,7 +178,7 @@ module AgUi
           ack(env, tool_call, error: "invalid JSON Patch: #{e.message}")
         else
           env[:state] = patched
-          env[:events] << { type: :state_delta, data: { delta: delta } }
+          env.emit(:state_delta, { delta: delta })
           ack(env, tool_call)
         end
 
@@ -186,17 +186,21 @@ module AgUi
         # :tool message and Loop::ToolResult continues) and emit TOOL_CALL_RESULT
         # on the wire — the exact shape server tools produce.
         def ack(env, tool_call, error: nil)
-          content = error ? { "status" => "error", "error" => error } : { "status" => "ok" }
+          if error
+            content = { "status" => "error", "error" => error }
+          else
+            content = { "status" => "ok" }
+          end
           json = JSON.generate(content)
           env[:messages].tool(json, tool_call_id: tool_call.id)
-          env[:events] << {
-            type: :tool_call_result,
-            data: {
-              message_id: SecureRandom.uuid,
+          env.emit(
+            :tool_call_result,
+            {
+              message_id:   SecureRandom.uuid,
               tool_call_id: tool_call.id,
-              content: json,
+              content:      json,
             },
-          }
+          )
         end
 
         def normalize(state)
@@ -223,6 +227,20 @@ end
 __END__
 
 describe "AgUi::Middleware::State" do
+
+  # Brute 6 replaced the env[:events] sink with the hooks registry, so a test
+  # that wants to see what a middleware emitted subscribes instead of reading
+  # an array off the env. This records the vocabulary State speaks, in
+  # emission order.
+  STATE_EVENTS = %i[state_snapshot state_delta tool_call_result].freeze
+
+  def recording(env, into)
+    hooks = Brute::Hooks::Registry.new
+    STATE_EVENTS.each do |event|
+      hooks.on(event) { |_env, data, _trace| into << { type: event, data: data } }
+    end
+    Brute::Hooks::Trace.new(env, hooks: hooks)
+  end
   snapshot_call = ->(args) do
     Brute::Message.new(
       role: :assistant, content: nil,
@@ -240,9 +258,9 @@ describe "AgUi::Middleware::State" do
   it "advertises both state tools idempotently and seeds env[:state] from input" do
     seen = nil
     mw = AgUi::Middleware::State.new(->(env) { seen = env }, state: { "theme" => "light" })
-    env = { messages: Brute.log, events: [], tools: [{ "name" => "navigate" }] }
-    mw.call(env)
-    mw.call(env) # second loop iteration — no dupes
+    env = { messages: Brute.log, tools: [{ "name" => "navigate" }] }
+    mw.call(recording(env, []))
+    mw.call(recording(env, [])) # second loop iteration — no dupes
 
     seen[:tools].map { |t| t["name"] }.should ==
       %w[navigate AGUISendStateSnapshot AGUISendStateDelta]
@@ -254,18 +272,19 @@ describe "AgUi::Middleware::State" do
     def definition.to_h = { "count" => 1 }
     seen = nil
     AgUi::Middleware::State.new(->(env) { seen = env }, state: definition)
-      .call({ messages: Brute.log, events: [], tools: [] })
+      .call(recording({ messages: Brute.log, tools: [] }, []))
     seen[:state].should == { "count" => 1 }
   end
 
   it "AGUISendStateSnapshot: sets state, emits STATE_SNAPSHOT + result, continues the run" do
     terminal = ->(env) { env[:messages] << snapshot_call.("snapshot" => { "count" => 3 }) }
-    env = { messages: Brute.log, events: [], tools: [], should_exit: true }
-    AgUi::Middleware::State.new(terminal).call(env)
+    env = { messages: Brute.log, tools: [], should_exit: true }
+    events = []
+    AgUi::Middleware::State.new(terminal).call(recording(env, events))
 
     env[:state].should == { "count" => 3 }
-    env[:events].map { |e| e[:type] }.should == %i[state_snapshot tool_call_result]
-    env[:events][0][:data][:snapshot].should == { "count" => 3 }
+    events.map { |e| e[:type] }.should == %i[state_snapshot tool_call_result]
+    events[0][:data][:snapshot].should == { "count" => 3 }
     env[:messages].last.role.should == :tool
     env[:messages].last.tool_call_id.should == "tc1"
     env[:messages].last.content.should == "{\"status\":\"ok\"}"
@@ -275,43 +294,47 @@ describe "AgUi::Middleware::State" do
   it "AGUISendStateDelta: patches state (Hana), emits STATE_DELTA with the raw ops" do
     delta = [{ "op" => "replace", "path" => "/theme", "value" => "dark" }]
     terminal = ->(env) { env[:messages] << delta_call.("delta" => delta) }
-    env = { messages: Brute.log, events: [], tools: [], state: { "theme" => "light" }, should_exit: true }
-    AgUi::Middleware::State.new(terminal).call(env)
+    env = { messages: Brute.log, tools: [], state: { "theme" => "light" }, should_exit: true }
+    events = []
+    AgUi::Middleware::State.new(terminal).call(recording(env, events))
 
     env[:state].should == { "theme" => "dark" }
-    env[:events].map { |e| e[:type] }.should == %i[state_delta tool_call_result]
-    env[:events][0][:data][:delta].should == delta
+    events.map { |e| e[:type] }.should == %i[state_delta tool_call_result]
+    events[0][:data][:delta].should == delta
     env[:should_exit].should == false
   end
 
   it "adds a nested key via delta against seeded state" do
     delta = [{ "op" => "add", "path" => "/documentEditor", "value" => { "activeTabId" => "doc-2" } }]
     terminal = ->(env) { env[:messages] << delta_call.("delta" => delta) }
-    env = { messages: Brute.log, events: [], tools: [], should_exit: true }
+    env = { messages: Brute.log, tools: [], should_exit: true }
+    events = []
     AgUi::Middleware::State.new(terminal, state: { "documentEditor" => { "activeTabId" => "doc-1" } })
-      .call(env)
+      .call(recording(env, events))
 
     env[:state].should == { "documentEditor" => { "activeTabId" => "doc-2" } }
-    env[:events][0][:type].should == :state_delta
+    events[0][:type].should == :state_delta
   end
 
   it "reports a bad patch back to the model as a tool error, no STATE_DELTA emitted" do
     delta = [{ "op" => "replace", "path" => "/missing/deep", "value" => 1 }]
     terminal = ->(env) { env[:messages] << delta_call.("delta" => delta) }
-    env = { messages: Brute.log, events: [], tools: [], state: {}, should_exit: true }
-    AgUi::Middleware::State.new(terminal).call(env)
+    env = { messages: Brute.log, tools: [], state: {}, should_exit: true }
+    events = []
+    AgUi::Middleware::State.new(terminal).call(recording(env, events))
 
-    env[:events].map { |e| e[:type] }.should == %i[tool_call_result]
-    JSON.parse(env[:events][0][:data][:content])["status"].should == "error"
+    events.map { |e| e[:type] }.should == %i[tool_call_result]
+    JSON.parse(events[0][:data][:content])["status"].should == "error"
     env[:messages].last.role.should == :tool
   end
 
   it "rejects a non-array delta and a non-object snapshot as tool errors" do
     [delta_call.("delta" => "nope"), snapshot_call.("snapshot" => "nope")].each do |msg|
       terminal = ->(env) { env[:messages] << msg }
-      env = { messages: Brute.log, events: [], tools: [] }
-      AgUi::Middleware::State.new(terminal).call(env)
-      JSON.parse(env[:events].last[:data][:content])["status"].should == "error"
+      env = { messages: Brute.log, tools: [] }
+      events = []
+      AgUi::Middleware::State.new(terminal).call(recording(env, events))
+      JSON.parse(events.last[:data][:content])["status"].should == "error"
     end
   end
 
@@ -325,17 +348,19 @@ describe "AgUi::Middleware::State" do
         ],
       )
     end
-    env = { messages: Brute.log, events: [], tools: [], should_exit: true }
-    AgUi::Middleware::State.new(terminal).call(env)
+    env = { messages: Brute.log, tools: [], should_exit: true }
+    events = []
+    AgUi::Middleware::State.new(terminal).call(recording(env, events))
 
-    env[:events].any? { |e| e[:type] == :state_snapshot }.should == true
+    events.any? { |e| e[:type] == :state_snapshot }.should == true
     env[:should_exit].should == true # browser still needs to run navigate
   end
 
   it "does nothing on a plain text turn" do
-    env = { messages: Brute.log, events: [], tools: [] }
-    AgUi::Middleware::State.new(->(e) { e[:messages].assistant("hi") }).call(env)
-    env[:events].should == []
+    env = { messages: Brute.log, tools: [] }
+    events = []
+    AgUi::Middleware::State.new(->(e) { e[:messages].assistant("hi") }).call(recording(env, events))
+    events.should == []
     env.key?(:should_exit).should == false
   end
 end

data/lib/ag_ui/middleware/system_prompt.rb

@@ -11,7 +11,7 @@ module AgUi
     #
     # Skips entirely when the history already carries a system message
     # (the client can send its own via system/developer roles).
-    class SystemPrompt
+    class SystemPrompt < Brute::Middleware::Base
       def initialize(app, prompt: nil, context: nil)
         @app = app
         @prompt = prompt

data/lib/ag_ui/middleware/tool_router.rb

@@ -26,7 +26,7 @@ module AgUi
     #     RUN_FINISHED and the browser executes it (multi-run model)
     #   - mixed turns: server tools still execute, but any client call
     #     ends the run
-    class ToolRouter
+    class ToolRouter < Brute::Middleware::Base
       def initialize(app, tools: nil, server_tools: nil)
         @app = app
         @client_tools = tools || []
@@ -72,9 +72,9 @@ module AgUi
 
         def server_definition(tool)
           {
-            "name" => tool[:name].to_s,
+            "name"        => tool[:name].to_s,
             "description" => tool[:description].to_s,
-            "parameters" => tool[:parameters] || { "type" => "object" },
+            "parameters"  => tool[:parameters] || { "type" => "object" },
           }
         end
 
@@ -82,7 +82,7 @@ module AgUi
           client_called = false
 
           tool_calls.each do |tool_call|
-            emit_call(env[:events], tool_call)
+            emit_call(env, tool_call)
 
             server = @server_tools[tool_call.name]
             if server
@@ -97,19 +97,16 @@ module AgUi
           end
         end
 
-        def emit_call(events, tool_call)
-          events << {
-            type: :tool_call_start,
-            data: { tool_call_id: tool_call.id, tool_call_name: tool_call.name },
-          }
-          events << {
-            type: :tool_call_args,
-            data: { tool_call_id: tool_call.id, delta: JSON.generate(tool_call.arguments) },
-          }
-          events << {
-            type: :tool_call_end,
-            data: { tool_call_id: tool_call.id },
-          }
+        def emit_call(env, tool_call)
+          env.emit(
+            :tool_call_start,
+            { tool_call_id: tool_call.id, tool_call_name: tool_call.name },
+          )
+          env.emit(
+            :tool_call_args,
+            { tool_call_id: tool_call.id, delta: JSON.generate(tool_call.arguments) },
+          )
+          env.emit(:tool_call_end, { tool_call_id: tool_call.id })
         end
 
         def execute_server_tool(env, tool_call, tool)
@@ -120,16 +117,20 @@ module AgUi
             result = { "error" => e.message }
           end
 
-          content = result.is_a?(String) ? result : JSON.generate(result)
+          if result.is_a?(String)
+            content = result
+          else
+            content = JSON.generate(result)
+          end
           env[:messages].tool(content, tool_call_id: tool_call.id)
-          env[:events] << {
-            type: :tool_call_result,
-            data: {
-              message_id: SecureRandom.uuid,
+          env.emit(
+            :tool_call_result,
+            {
+              message_id:   SecureRandom.uuid,
               tool_call_id: tool_call.id,
-              content: content,
+              content:      content,
             },
-          }
+          )
         end
     end
   end
@@ -138,6 +139,20 @@ end
 __END__
 
 describe "AgUi::Middleware::ToolRouter" do
+  # Brute 6 replaced the env[:events] sink with the hooks registry, so a test
+  # that wants to see what a middleware emitted subscribes instead of reading
+  # an array off the env. This records the AG-UI tool vocabulary in emission
+  # order, which keeps the assertions below the shape they always had.
+  TOOL_EVENTS = %i[tool_call_start tool_call_args tool_call_end tool_call_result].freeze
+
+  def recording(env, into)
+    hooks = Brute::Hooks::Registry.new
+    TOOL_EVENTS.each do |event|
+      hooks.on(event) { |_env, data, _trace| into << { type: event, data: data } }
+    end
+    Brute::Hooks::Trace.new(env, hooks: hooks)
+  end
+
   it "advertises client and server tools idempotently across iterations" do
     seen = nil
     server_tool = { name: "get_time", description: "Now", handler: -> (_args) { "12:00" } }
@@ -147,9 +162,9 @@ describe "AgUi::Middleware::ToolRouter" do
       server_tools: [server_tool],
     )
 
-    env = { messages: Brute.log, events: [] }
-    mw.call(env)
-    mw.call(env) # second loop iteration
+    env = { messages: Brute.log }
+    mw.call(recording(env, []))
+    mw.call(recording(env, [])) # second loop iteration
 
     seen.map { |t| t["name"] }.should == %w[navigate get_time]
     seen.last["parameters"].should == { "type" => "object" }
@@ -169,17 +184,18 @@ describe "AgUi::Middleware::ToolRouter" do
       )
     end
 
-    env = { messages: Brute.log, events: [] }
-    AgUi::Middleware::ToolRouter.new(terminal, server_tools: [server_tool]).call(env)
+    env = { messages: Brute.log }
+    events = []
+    AgUi::Middleware::ToolRouter.new(terminal, server_tools: [server_tool]).call(recording(env, events))
 
     env[:messages].last.role.should == :tool
     env[:messages].last.tool_call_id.should == "tc1"
     env[:messages].last.content.should == "{\"found\":42}"
 
-    env[:events].map { |e| e[:type] }.should == %i[
+    events.map { |e| e[:type] }.should == %i[
       tool_call_start tool_call_args tool_call_end tool_call_result
     ]
-    env[:events].last[:data][:content].should == "{\"found\":42}"
+    events.last[:data][:content].should == "{\"found\":42}"
     env.key?(:should_exit).should == false
   end
 
@@ -192,8 +208,8 @@ describe "AgUi::Middleware::ToolRouter" do
       )
     end
 
-    env = { messages: Brute.log, events: [] }
-    AgUi::Middleware::ToolRouter.new(terminal, server_tools: [server_tool]).call(env)
+    env = { messages: Brute.log }
+    AgUi::Middleware::ToolRouter.new(terminal, server_tools: [server_tool]).call(recording(env, []))
 
     env[:messages].last.content.should == "{\"error\":\"kaput\"}"
     env.key?(:should_exit).should == false
@@ -211,11 +227,12 @@ describe "AgUi::Middleware::ToolRouter" do
       )
     end
 
-    env = { messages: Brute.log, events: [] }
-    AgUi::Middleware::ToolRouter.new(terminal, server_tools: [server_tool]).call(env)
+    env = { messages: Brute.log }
+    events = []
+    AgUi::Middleware::ToolRouter.new(terminal, server_tools: [server_tool]).call(recording(env, events))
 
     env[:should_exit].should == true
-    env[:events].count { |e| e[:type] == :tool_call_result }.should == 1
+    events.count { |e| e[:type] == :tool_call_result }.should == 1
   end
 
   it "emits TOOL_CALL events and exits when the turn ends on client tool calls" do
@@ -229,23 +246,25 @@ describe "AgUi::Middleware::ToolRouter" do
       )
     end
 
-    env = { messages: Brute.log, events: [] }
-    AgUi::Middleware::ToolRouter.new(terminal).call(env)
+    env = { messages: Brute.log }
+    events = []
+    AgUi::Middleware::ToolRouter.new(terminal).call(recording(env, events))
 
-    env[:events].map { |e| e[:type] }.should == %i[
+    events.map { |e| e[:type] }.should == %i[
       tool_call_start tool_call_args tool_call_end
       tool_call_start tool_call_args tool_call_end
     ]
-    env[:events][0][:data].should == { tool_call_id: "tc1", tool_call_name: "navigate" }
-    env[:events][1][:data][:delta].should == "{\"path\":\"/data\"}"
+    events[0][:data].should == { tool_call_id: "tc1", tool_call_name: "navigate" }
+    events[1][:data][:delta].should == "{\"path\":\"/data\"}"
     env[:should_exit].should == true
   end
 
   it "does nothing on the way out for plain text turns" do
-    env = { messages: Brute.log, events: [] }
-    AgUi::Middleware::ToolRouter.new(->(e) { e[:messages].assistant("hi") }).call(env)
+    env = { messages: Brute.log }
+    events = []
+    AgUi::Middleware::ToolRouter.new(->(e) { e[:messages].assistant("hi") }).call(recording(env, events))
 
-    env[:events].should == []
+    events.should == []
     env.key?(:should_exit).should == false
   end
 end

data/lib/ag_ui/protocol/json_schema/definition.rb

@@ -33,12 +33,12 @@ module AgUi
             camel = snake[k] || k
 
             if props.include?(camel)
-              @data[camel] = if value.is_a?(Definition)
-                value.to_h
+              if value.is_a?(Definition)
+                @data[camel] = value.to_h
               elsif (ref_info = refs[camel])
-                wrap_ref(value, ref_info)
+                @data[camel] = wrap_ref(value, ref_info)
               else
-                value
+                @data[camel] = value
               end
             end
           end
@@ -91,7 +91,7 @@ module AgUi
             raise ValidationError.new(
               errors,
               definition_name: self.class.definition_name,
-              data: to_h,
+              data:            to_h,
             )
           end
         end

data/lib/ag_ui/protocol/json_schema.rb

@@ -129,14 +129,18 @@ module AgUi
             properties.each do |camel_key, prop_schema|
               schema = unwrap_optional(prop_schema)
 
-              kind, ref =
-                if (r = schema["$ref"])
-                  [:object, r]
-                elsif schema["type"] == "array" && (r = schema.dig("items", "$ref"))
-                  [:array, r]
-                elsif schema["type"] == "object" && (r = schema.dig("additionalProperties", "$ref"))
-                  [:map, r]
-                end
+              kind = nil
+              ref = nil
+              if (r = schema["$ref"])
+                kind = :object
+                ref = r
+              elsif schema["type"] == "array" && (r = schema.dig("items", "$ref"))
+                kind = :array
+                ref = r
+              elsif schema["type"] == "object" && (r = schema.dig("additionalProperties", "$ref"))
+                kind = :map
+                ref = r
+              end
 
               if ref
                 name = ref_name_for(ref)
@@ -168,13 +172,13 @@ module AgUi
           end
 
           def build_snake_to_camel(camel_keys)
-            map = {}
-            camel_keys.each do |camel|
-              snake = camel_to_snake(camel)
-              map[snake] = camel
-              map[camel] = camel
+            {}.tap do |map|
+              camel_keys.each do |camel|
+                snake = camel_to_snake(camel)
+                map[snake] = camel
+                map[camel] = camel
+              end
             end
-            map
           end
 
           def camel_to_snake(str)

data/lib/ag_ui/run_input.rb

@@ -42,7 +42,7 @@ module AgUi
           validation_error = Protocol::JsonSchema::ValidationError.new(
             errors,
             definition_name: "RunAgentInput",
-            data: raw,
+            data:            raw,
           )
           raise InvalidError, validation_error.message
         end

data/lib/ag_ui/server/info.rb

@@ -26,19 +26,19 @@ module AgUi
           end
 
           base = {
-            "version" => VERSION_PARITY,
-            "agents" => { agent_id => agent },
+            "version"                       => VERSION_PARITY,
+            "agents"                        => { agent_id => agent },
             "audioFileTranscriptionEnabled" => false,
-            "mode" => "sse",
-            "threadEndpoints" => {
-              "list" => false,
-              "inspect" => false,
-              "mutations" => false,
+            "mode"                          => "sse",
+            "threadEndpoints"               => {
+              "list"             => false,
+              "inspect"          => false,
+              "mutations"        => false,
               "realtimeMetadata" => false,
             },
-            "a2uiEnabled" => a2ui_enabled,
-            "openGenerativeUIEnabled" => false,
-            "telemetryDisabled" => true,
+            "a2uiEnabled"                   => a2ui_enabled,
+            "openGenerativeUIEnabled"       => false,
+            "telemetryDisabled"             => true,
           }
 
           if a2ui_enabled

data/lib/ag_ui/server/middleware/sse_stream.rb

@@ -67,9 +67,9 @@ module AgUi
                  on_event: nil, on_finish: nil, on_task: nil, &block)
           stream = SSE::Stream.new(
             thread_id: thread_id,
-            run_id: run_id,
-            validate: validate,
-            on_event: on_event,
+            run_id:    run_id,
+            validate:  validate,
+            on_event:  on_event,
           )
 
           @env["ag_ui.stream"] = stream

data/lib/ag_ui/server/sse/event_encoder.rb

@@ -23,20 +23,20 @@ module AgUi
 
         private
 
-        def strip_nils(value)
-          case value
-          when Hash
-            value.each_with_object({}) do |(k, v), out|
-              unless v.nil?
-                out[k] = strip_nils(v)
+          def strip_nils(value)
+            case value
+            when Hash
+              value.each_with_object({}) do |(k, v), out|
+                unless v.nil?
+                  out[k] = strip_nils(v)
+                end
               end
+            when Array
+              value.map { |v| strip_nils(v) }
+            else
+              value
             end
-          when Array
-            value.map { |v| strip_nils(v) }
-          else
-            value
           end
-        end
       end
     end
   end

data/lib/ag_ui/server/sse/stream.rb

@@ -90,7 +90,11 @@ module AgUi
           property_defaults = AgUi::Protocol::JsonSchema.raw_schema
             .dig("definitions", definition_name, "properties")
             .each_with_object({}) do |(camel, prop), defaults|
-              value = prop["default"].nil? ? prop["const"] : prop["default"]
+              if prop["default"].nil?
+                value = prop["const"]
+              else
+                value = prop["default"]
+              end
               unless value.nil?
                 defaults[camel] = value
               end