ag-ui 0.2.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ba6811e09735cfc95262ba711a5e953a92d9af8d78ea8b13867f1d1c60fbeedc
-  data.tar.gz: 75e995ce5c17476566258e05e5b56de4481b3df8539554e91d687363e15ad456
+  metadata.gz: 226774b66734c0e15d3668f1333c061ef41caee6fd160a3d74227ccb0766b43e
+  data.tar.gz: 48926b867c6e753d0a6f4865b8636704b826add52510522afee69726d05de4d7
 SHA512:
-  metadata.gz: 7e1bfaaa5c833b60ab7ce9a99d069abd3603eaf8366abf355b73688b07c54fb1d76fd280fb46a00e3e0e01a5cbf9de8d7b4ce7e59b581679eff92f7f891842c2
-  data.tar.gz: 205c4a2f519bcbfcf1fcb975de4929da568633d1358a793c78b042424c867918cce430dd6c9289b965ead31bb1a218a4d706b14e7476093a2ac42d7a10a1e21b
+  metadata.gz: 144142fdc3950ec5925887614db47e416e3bc92a6810fb3cd7bea146de1a3b54de3655d110fe6bba4246761a70a88f9d26c9c2d7101657a3848c52c86dff5fcb
+  data.tar.gz: 8b62bdfd10acb644e867aa8f0ac71e1c4fbb1897644f43c71642c05076792fe32a030244c0f7d4aa2451774f9a357a226e60fa784bffa0c53db6c147f8fa0034

data/data/ag_ui.json

@@ -1,5 +1,5 @@
 {
-  "$comment": "Generated by data/generate-ag-ui-schema.py from ag-ui sdks/python (77 models). Do not edit.",
+  "$comment": "Generated by bin/generate-ag-ui-schema from ag-ui sdks/python (77 models). Do not edit.",
   "definitions": {
     "ActivityDeltaEvent": {
       "additionalProperties": true,

data/lib/ag_ui/a2ui/recovery.rb

@@ -23,8 +23,8 @@ module AgUi
       A2UI_RECOVERY_ACTIVITY_TYPE = "a2ui_recovery"
 
       NO_TOOL_CALL_ERROR = {
-        "code" => "empty_components",
-        "path" => "components",
+        "code"    => "empty_components",
+        "path"    => "components",
         "message" => "Sub-agent did not call render_a2ui",
       }.freeze
 
@@ -57,15 +57,22 @@ module AgUi
           prompt = augment_prompt_with_validation_errors(base_prompt, last_errors)
           args = invoke_subagent.call(prompt, attempt)
 
-          record =
-            if args.nil? || args.empty?
-              { "attempt" => attempt, "ok" => false, "errors" => [NO_TOOL_CALL_ERROR] }
+          if args.nil? || args.empty?
+            record = { "attempt" => attempt, "ok" => false, "errors" => [NO_TOOL_CALL_ERROR] }
+          else
+            if args["components"].is_a?(Array)
+              components = args["components"]
+            else
+              components = []
+            end
+            if args["data"].is_a?(Hash)
+              data = args["data"]
             else
-              components = args["components"].is_a?(Array) ? args["components"] : []
-              data = args["data"].is_a?(Hash) ? args["data"] : {}
-              result = Validate.validate_components(components: components, data: data, catalog: catalog)
-              { "attempt" => attempt, "ok" => result["valid"], "errors" => result["errors"] }
+              data = {}
             end
+            result = Validate.validate_components(components: components, data: data, catalog: catalog)
+            record = { "attempt" => attempt, "ok" => result["valid"], "errors" => result["errors"] }
+          end
 
           attempts << record
           on_attempt&.call(record)
@@ -82,7 +89,7 @@ module AgUi
             {
               "envelope" => exhausted_envelope(max_attempts, attempts),
               "attempts" => attempts,
-              "ok" => false,
+              "ok"       => false,
             }
           end
         end
@@ -91,8 +98,8 @@ module AgUi
       def exhausted_envelope(max_attempts, attempts)
         JSON.generate(
           {
-            "error" => "Failed to generate valid A2UI after #{max_attempts} attempt(s)",
-            "code" => "a2ui_recovery_exhausted",
+            "error"    => "Failed to generate valid A2UI after #{max_attempts} attempt(s)",
+            "code"     => "a2ui_recovery_exhausted",
             "attempts" => attempts,
           },
         )

data/lib/ag_ui/a2ui/validate.rb

@@ -26,42 +26,66 @@ module AgUi
       def validate_components(components:, data: nil, catalog: nil, validate_bindings: true)
         if !components.is_a?(Array) || components.empty?
           {
-            "valid" => false,
+            "valid"  => false,
             "errors" => [{
-              "code" => "empty_components",
-              "path" => "components",
+              "code"    => "empty_components",
+              "path"    => "components",
               "message" => "A2UI components must be a non-empty array",
-            }],
+            }
+],
           }
         else
-          validate_populated(components, data, catalog, validate_bindings)
+          validate_populated(
+            components,
+            data,
+            catalog,
+            validate_bindings,
+          )
         end
       end
 
       def validate_populated(components, data, catalog, validate_bindings)
         errors = []
         ids = collect_ids(components, errors)
-        catalog_components = catalog.is_a?(Hash) ? (catalog["components"] || {}) : {}
+        if catalog.is_a?(Hash)
+          catalog_components = (catalog["components"] || {})
+        else
+          catalog_components = {}
+        end
 
         components.each_with_index do |comp, i|
           check_identity(comp, i, errors)
-          check_catalog(comp, i, catalog, catalog_components, errors)
-          check_refs_and_bindings(comp, i, ids, catalog_components, data, validate_bindings, errors)
+          check_catalog(
+            comp,
+            i,
+            catalog,
+            catalog_components,
+            errors,
+          )
+          check_refs_and_bindings(
+            comp,
+            i,
+            ids,
+            catalog_components,
+            data,
+            validate_bindings,
+            errors,
+          )
         end
 
         find_child_cycles(components, catalog_components).each do |cycle|
           chain = (cycle + [cycle.first]).join(" -> ")
           errors << {
-            "code" => "child_cycle",
-            "path" => "components[id=#{cycle.first}]",
+            "code"    => "child_cycle",
+            "path"    => "components[id=#{cycle.first}]",
             "message" => "Child reference cycle detected: #{chain}",
           }
         end
 
         unless components.any? { |c| c.is_a?(Hash) && c["id"] == "root" }
           errors << {
-            "code" => "no_root",
-            "path" => "components",
+            "code"    => "no_root",
+            "path"    => "components",
             "message" => "No component has id 'root'",
           }
         end
@@ -70,61 +94,77 @@ module AgUi
       end
 
       def collect_ids(components, errors)
-        ids = Set.new
-        seen = Set.new
-        components.each do |comp|
-          cid = comp.is_a?(Hash) ? comp["id"] : nil
-          if cid.is_a?(String)
-            if seen.include?(cid)
-              errors << {
-                "code" => "duplicate_id",
-                "path" => "components[id=#{cid}]",
-                "message" => "Duplicate component id '#{cid}'",
-              }
+        Set.new.tap do |ids|
+          seen = Set.new
+          components.each do |comp|
+            if comp.is_a?(Hash)
+              cid = comp["id"]
+            else
+              cid = nil
+            end
+            if cid.is_a?(String)
+              if seen.include?(cid)
+                errors << {
+                  "code"    => "duplicate_id",
+                  "path"    => "components[id=#{cid}]",
+                  "message" => "Duplicate component id '#{cid}'",
+                }
+              end
+              seen << cid
+              ids << cid
             end
-            seen << cid
-            ids << cid
           end
         end
-        ids
       end
 
       def check_identity(comp, index, errors)
-        cid = comp.is_a?(Hash) ? comp["id"] : nil
-        ctype = comp.is_a?(Hash) ? comp["component"] : nil
+        if comp.is_a?(Hash)
+          cid = comp["id"]
+        else
+          cid = nil
+        end
+        if comp.is_a?(Hash)
+          ctype = comp["component"]
+        else
+          ctype = nil
+        end
 
         unless cid.is_a?(String) && !cid.empty?
           errors << {
-            "code" => "missing_id",
-            "path" => "components[#{index}].id",
+            "code"    => "missing_id",
+            "path"    => "components[#{index}].id",
             "message" => "Component at index #{index} is missing a string 'id'",
           }
         end
         unless ctype.is_a?(String) && !ctype.empty?
           errors << {
-            "code" => "missing_component_type",
-            "path" => "components[#{index}].component",
+            "code"    => "missing_component_type",
+            "path"    => "components[#{index}].component",
             "message" => "Component at index #{index} is missing a string 'component' type",
           }
         end
       end
 
       def check_catalog(comp, index, catalog, catalog_components, errors)
-        ctype = comp.is_a?(Hash) ? comp["component"] : nil
+        if comp.is_a?(Hash)
+          ctype = comp["component"]
+        else
+          ctype = nil
+        end
         if catalog && ctype.is_a?(String)
           schema = catalog_components[ctype]
           if schema.nil?
             errors << {
-              "code" => "unknown_component",
-              "path" => "components[#{index}].component",
+              "code"    => "unknown_component",
+              "path"    => "components[#{index}].component",
               "message" => "Component type '#{ctype}' is not in the catalog",
             }
           else
             (schema["required"] || []).each do |req|
               unless comp.is_a?(Hash) && comp.key?(req)
                 errors << {
-                  "code" => "missing_required_prop",
-                  "path" => "components[#{index}].#{req}",
+                  "code"    => "missing_required_prop",
+                  "path"    => "components[#{index}].#{req}",
                   "message" => "Component '#{ctype}' (index #{index}) is missing required prop '#{req}'",
                 }
               end
@@ -136,13 +176,17 @@ module AgUi
       def check_refs_and_bindings(comp, index, ids, catalog_components, data, validate_bindings, errors)
         if comp.is_a?(Hash)
           ctype = comp["component"]
-          schema = ctype.is_a?(String) ? catalog_components[ctype] : nil
+          if ctype.is_a?(String)
+            schema = catalog_components[ctype]
+          else
+            schema = nil
+          end
 
           collect_component_ref_edges(comp, schema).each do |(ref_path, ref)|
             unless ids.include?(ref)
               errors << {
-                "code" => "unresolved_child",
-                "path" => "components[#{index}].#{ref_path}",
+                "code"    => "unresolved_child",
+                "path"    => "components[#{index}].#{ref_path}",
                 "message" => "Child reference '#{ref}' does not match any component id",
               }
             end
@@ -152,8 +196,8 @@ module AgUi
             collect_absolute_binding_paths(comp, []).each do |path|
               unless absolute_path_resolves?(path, data || {})
                 errors << {
-                  "code" => "unresolved_binding",
-                  "path" => "components[#{index}]",
+                  "code"    => "unresolved_binding",
+                  "path"    => "components[#{index}]",
                   "message" => "Binding path '#{path}' does not resolve in the data model",
                 }
               end
@@ -193,21 +237,21 @@ module AgUi
       # A bare string id, or a {componentId: ...} template — the two child
       # reference shapes.
       def collect_child_refs(children)
-        refs = []
-        push = ->(v) do
-          if v.is_a?(String)
-            refs << v
-          elsif v.is_a?(Hash) && v["componentId"].is_a?(String)
-            refs << v["componentId"]
+        [].tap do |refs|
+          push = ->(v) do
+            if v.is_a?(String)
+              refs << v
+            elsif v.is_a?(Hash) && v["componentId"].is_a?(String)
+              refs << v["componentId"]
+            end
           end
-        end
 
-        if children.is_a?(Array)
-          children.each { |v| push.(v) }
-        else
-          push.(children)
+          if children.is_a?(Array)
+            children.each { |v| push.(v) }
+          else
+            push.(children)
+          end
         end
-        refs
       end
 
       # (path_suffix, ref_id) pairs for every child reference a component
@@ -217,47 +261,60 @@ module AgUi
       # array-of-object item schemas honoured per element — finds Tabs
       # tabItems[].child). Unmarked props are data, never refs.
       def collect_component_ref_edges(comp, schema)
-        edges = []
+        [].tap do |edges|
 
-        push_single = ->(field, value) do
-          collect_child_refs(value).each { |ref| edges << [field, ref] }
-        end
-        push_list = ->(field, value) do
-          if value.is_a?(Array)
-            value.each_with_index do |item, k|
-              collect_child_refs(item).each { |ref| edges << ["#{field}[#{k}]", ref] }
-            end
-          else
+          push_single = ->(field, value) do
             collect_child_refs(value).each { |ref| edges << [field, ref] }
           end
-        end
+          push_list = ->(field, value) do
+            if value.is_a?(Array)
+              value.each_with_index do |item, k|
+                collect_child_refs(item).each { |ref| edges << ["#{field}[#{k}]", ref] }
+              end
+            else
+              collect_child_refs(value).each { |ref| edges << [field, ref] }
+            end
+          end
 
-        push_single.("child", comp["child"])
-        push_list.("children", comp["children"])
+          push_single.("child", comp["child"])
+          push_list.("children", comp["children"])
 
-        props = schema.is_a?(Hash) ? schema["properties"] : nil
-        if props.is_a?(Hash)
-          props.each do |field, prop_schema|
-            if %w[child children].include?(field) || !prop_schema.is_a?(Hash)
-              next
-            end
+          if schema.is_a?(Hash)
+            props = schema["properties"]
+          else
+            props = nil
+          end
+          if props.is_a?(Hash)
+            props.each do |field, prop_schema|
+              if %w[child children].include?(field) || !prop_schema.is_a?(Hash)
+                next
+              end
 
-            case prop_schema["format"]
-            when "componentRef"
-              push_single.(field, comp[field])
-            when "componentRefList"
-              push_list.(field, comp[field])
-            else
-              collect_array_item_edges(comp, field, prop_schema, edges)
+              case prop_schema["format"]
+              when "componentRef"
+                push_single.(field, comp[field])
+              when "componentRefList"
+                push_list.(field, comp[field])
+              else
+                collect_array_item_edges(
+                  comp,
+                  field,
+                  prop_schema,
+                  edges,
+                )
+              end
             end
           end
         end
-        edges
       end
 
       def collect_array_item_edges(comp, field, prop_schema, edges)
         items = prop_schema["items"]
-        item_props = items.is_a?(Hash) ? items["properties"] : nil
+        if items.is_a?(Hash)
+          item_props = items["properties"]
+        else
+          item_props = nil
+        end
         arr_val = comp[field]
         if prop_schema["type"] == "array" && item_props.is_a?(Hash) && arr_val.is_a?(Array)
           arr_val.each_with_index do |item, k|
@@ -289,15 +346,19 @@ module AgUi
       end
 
       def child_adjacency(components, catalog_components)
-        adj = {}
-        components.each do |comp|
-          if comp.is_a?(Hash) && comp["id"].is_a?(String)
-            ctype = comp["component"]
-            schema = ctype.is_a?(String) ? catalog_components[ctype] : nil
-            adj[comp["id"]] = collect_component_ref_edges(comp, schema).map { |(_p, ref)| ref }
+        {}.tap do |adj|
+          components.each do |comp|
+            if comp.is_a?(Hash) && comp["id"].is_a?(String)
+              ctype = comp["component"]
+              if ctype.is_a?(String)
+                schema = catalog_components[ctype]
+              else
+                schema = nil
+              end
+              adj[comp["id"]] = collect_component_ref_edges(comp, schema).map { |(_p, ref)| ref }
+            end
           end
         end
-        adj
       end
 
       # Unique child-reference cycles via ITERATIVE DFS (explicit frame