datagrout-conduit 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8fcac4a1dc9cdb77ca7e0b1b75eb44fcacf867966312e05f21b93c0cba63a6cb
-  data.tar.gz: 7faa4fc8a6c23fb5eee90fb07b2cd02caee23245bc68899d297a32d693c1b464
+  metadata.gz: 28e196cb29ede549875a2c3ecb87eeff2b2c6479d6a24a6a095d00b4891ff11c
+  data.tar.gz: 45eeee43e6fe5eaee59fd2527c8d48b9317cece38d503637b7225abf11d6b67d
 SHA512:
-  metadata.gz: cca7ceddb65cb22cd3283659a6b44a792e683f4c57d93f9fe49226f00a71890fc59237f97c1cf13d56849febc453f7a0d84cd2ca4cfba5e967222a268c46f2b5
-  data.tar.gz: 95ab6ae19cf9a6a1b23b9444f7063fb0bcdd64d1a407af589bd00c543eb349aec98226dcfcba06598a879a6150578fbbf872fc358b84c4b9da38f55f45530228
+  metadata.gz: 4e763c86181e3d7ef415e3bf07cb7544d76bb064d725c78fbf006a6adc8f3ef95922cee7a375bdf5aded71c26679cf06d30548c7e7cb56fd672c2b7f212b40d0
+  data.tar.gz: 44eb007fc146df62969f0428b1d0ced58c8cba78167ca67df5744a25314686023b99a73eb6a4a4b1b2a11377921969a3cb7b8b2e88e4e11a635790ed7b29b405

data/lib/datagrout_conduit/client.rb

@@ -193,6 +193,34 @@ module DatagroutConduit
       result["messages"] || []
     end
 
+    # ================================================================
+    # Namespace Accessors
+    # ================================================================
+
+    def prism
+      @prism ||= PrismNamespace.new(self)
+    end
+
+    def logic
+      @logic ||= LogicNamespace.new(self)
+    end
+
+    def warden
+      @warden ||= WardenNamespace.new(self)
+    end
+
+    def deliverables
+      @deliverables ||= DeliverablesNamespace.new(self)
+    end
+
+    def ephemerals
+      @ephemerals ||= EphemeralsNamespace.new(self)
+    end
+
+    def flow
+      @flow ||= FlowNamespace.new(self)
+    end
+
     # ================================================================
     # DataGrout Extensions
     # ================================================================
@@ -225,6 +253,23 @@ module DatagroutConduit
       call_dg_tool("data-grout/discovery.perform", params)
     end
 
+    # Execute multiple tool calls in a single gateway request.
+    #
+    # Each element should be a hash with "tool" and "args" keys.
+    # Returns an array of results in the same order as the input calls.
+    #
+    #   results = client.perform_batch([
+    #     { "tool" => "data-grout/data.count", "args" => { "data" => [1, 2, 3] } },
+    #     { "tool" => "data-grout/data.keys",  "args" => { "data" => { "a" => 1 } } }
+    #   ])
+    def perform_batch(calls)
+      warn_if_not_dg("perform_batch")
+      ensure_initialized!
+
+      result = call_dg_tool("data-grout/discovery.perform", calls)
+      result.is_a?(Array) ? result : [result]
+    end
+
     # Start or continue a guided workflow.
     def guide(goal: nil, session_id: nil, choice: nil)
       warn_if_not_dg("guide")
@@ -239,32 +284,6 @@ module DatagroutConduit
       GuidedSession.new(self, GuideState.from_hash(result))
     end
 
-    # Execute a multi-step workflow plan.
-    def flow_into(plan, validate_ctc: true, save_as_skill: false, input_data: nil)
-      warn_if_not_dg("flow_into")
-      ensure_initialized!
-
-      params = {
-        "plan" => plan,
-        "validate_ctc" => validate_ctc,
-        "save_as_skill" => save_as_skill
-      }
-      params["input_data"] = input_data if input_data
-
-      call_dg_tool("data-grout/flow.into", params)
-    end
-
-    # Semantic type transformation via Prism.
-    def prism_focus(data:, source_type:, target_type:, source_annotations: nil, target_annotations: nil, context: nil)
-      params = { "data" => data, "source_type" => source_type, "target_type" => target_type }
-      params["source_annotations"] = source_annotations if source_annotations
-      params["target_annotations"] = target_annotations if target_annotations
-      params["context"] = context if context
-      warn_if_not_dg("prism_focus")
-      ensure_initialized!
-      call_dg_tool("data-grout/prism.focus", params)
-    end
-
     # Semantic discovery plan — return a ranked list of tools for a goal.
     # At least one of `goal:` or `query:` must be provided.
     def plan(goal: nil, query: nil, **opts)
@@ -285,150 +304,6 @@ module DatagroutConduit
       call_dg_tool("data-grout/discovery.plan", params)
     end
 
-    # Transform / reshape a payload via Prism.
-    def refract(goal:, payload:, **opts)
-      params = { "goal" => goal, "payload" => payload }
-      params["verbose"] = opts[:verbose] if opts.key?(:verbose)
-      params["chart"] = opts[:chart] if opts.key?(:chart)
-      warn_if_not_dg("refract")
-      ensure_initialized!
-      call_dg_tool("data-grout/prism.refract", params)
-    end
-
-    # Generate a chart/visual from a payload via Prism.
-    def chart(goal:, payload:, **opts)
-      params = { "goal" => goal, "payload" => payload }
-      params["format"] = opts[:format] if opts[:format]
-      params["chart_type"] = opts[:chart_type] if opts[:chart_type]
-      params["title"] = opts[:title] if opts[:title]
-      params["x_label"] = opts[:x_label] if opts[:x_label]
-      params["y_label"] = opts[:y_label] if opts[:y_label]
-      params["width"] = opts[:width] if opts[:width]
-      params["height"] = opts[:height] if opts[:height]
-      warn_if_not_dg("chart")
-      ensure_initialized!
-      call_dg_tool("data-grout/prism.chart", params)
-    end
-
-    # Generate a document toward a natural-language goal.
-    def render(goal:, payload: nil, format: "markdown", sections: nil, **opts)
-      params = { "goal" => goal, "format" => format }.merge(normalize_hash(opts))
-      params["payload"] = payload if payload
-      params["sections"] = sections if sections
-      warn_if_not_dg("render")
-      ensure_initialized!
-      call_dg_tool("data-grout/prism.render", params)
-    end
-
-    # Convert content to another format (no LLM). Supports csv, xlsx, pdf, json, etc.
-    def export(content:, format:, style: nil, metadata: nil, **opts)
-      params = { "content" => content, "format" => format }.merge(normalize_hash(opts))
-      params["style"] = style if style
-      params["metadata"] = metadata if metadata
-      warn_if_not_dg("export")
-      ensure_initialized!
-      call_dg_tool("data-grout/prism.export", params)
-    end
-
-    # Pause workflow for human approval.
-    def request_approval(action:, details: nil, reason: nil, context: nil, **opts)
-      params = { "action" => action }.merge(normalize_hash(opts))
-      params["details"] = details if details
-      params["reason"] = reason if reason
-      params["context"] = context if context
-      warn_if_not_dg("request_approval")
-      ensure_initialized!
-      call_dg_tool("data-grout/flow.request-approval", params)
-    end
-
-    # Request user clarification for missing fields.
-    def request_feedback(missing_fields:, reason:, current_data: nil, suggestions: nil, context: nil, **opts)
-      params = { "missing_fields" => missing_fields, "reason" => reason }.merge(normalize_hash(opts))
-      params["current_data"] = current_data if current_data
-      params["suggestions"] = suggestions if suggestions
-      params["context"] = context if context
-      warn_if_not_dg("request_feedback")
-      ensure_initialized!
-      call_dg_tool("data-grout/flow.request-feedback", params)
-    end
-
-    # List recent tool executions for the current server.
-    def execution_history(limit: 50, offset: 0, status: nil, refractions_only: false, **opts)
-      params = { "limit" => limit, "offset" => offset, "refractions_only" => refractions_only }.merge(normalize_hash(opts))
-      params["status"] = status if status
-      warn_if_not_dg("execution_history")
-      ensure_initialized!
-      call_dg_tool("data-grout/inspect.execution-history", params)
-    end
-
-    # Get details for a specific execution.
-    def execution_details(execution_id:)
-      params = { "execution_id" => execution_id }
-      warn_if_not_dg("execution_details")
-      ensure_initialized!
-      call_dg_tool("data-grout/inspect.execution-details", params)
-    end
-
-    # ================================================================
-    # Logic Cell Methods
-    # ================================================================
-
-    # Assert a fact or statement into the logic cell.
-    def remember(statement: nil, facts: nil, tag: nil)
-      raise ArgumentError, "must provide statement or facts" unless statement || facts
-
-      params = {}
-      params["statement"] = statement if statement
-      params["facts"] = facts if facts
-      params["tag"] = tag if tag
-      warn_if_not_dg("remember")
-      ensure_initialized!
-      call_dg_tool("data-grout/logic.remember", params)
-    end
-
-    # Query the logic cell by question or patterns.
-    def query_cell(question: nil, patterns: nil, limit: nil)
-      raise ArgumentError, "must provide question or patterns" unless question || patterns
-
-      params = {}
-      params["question"] = question if question
-      params["patterns"] = patterns if patterns
-      params["limit"] = limit if limit
-      warn_if_not_dg("query_cell")
-      ensure_initialized!
-      call_dg_tool("data-grout/logic.query", params)
-    end
-
-    # Remove facts from the logic cell by handles or pattern.
-    def forget(handles: nil, pattern: nil)
-      raise ArgumentError, "must provide handles or pattern" unless handles || pattern
-
-      params = {}
-      params["handles"] = handles if handles
-      params["pattern"] = pattern if pattern
-      warn_if_not_dg("forget")
-      ensure_initialized!
-      call_dg_tool("data-grout/logic.forget", params)
-    end
-
-    # Assert a constraint rule into the logic cell.
-    def constrain(rule:, tag: nil)
-      params = { "rule" => rule }
-      params["tag"] = tag if tag
-      warn_if_not_dg("constrain")
-      ensure_initialized!
-      call_dg_tool("data-grout/logic.constrain", params)
-    end
-
-    # Reflect on known facts about an entity.
-    def reflect(entity: nil, summary_only: false)
-      params = { "summary_only" => summary_only }
-      params["entity"] = entity if entity
-      warn_if_not_dg("reflect")
-      ensure_initialized!
-      call_dg_tool("data-grout/logic.reflect", params)
-    end
-
     # Call any DataGrout first-party tool by short name.
     # e.g. client.dg("prism.render", { payload: data, goal: "summary" })
     def dg(tool_short_name, params = {})

data/lib/datagrout_conduit/namespaces/deliverables.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module DatagroutConduit
+  class DeliverablesNamespace
+    def initialize(client)
+      @client = client
+    end
+
+    def register(params = {})
+      dg_call("deliverables.register", params)
+    end
+
+    def list(params = {})
+      dg_call("deliverables.list", params)
+    end
+
+    def get(ref_id)
+      dg_call("deliverables.get", { "ref" => ref_id })
+    end
+
+    private
+
+    def dg_call(short_name, params)
+      @client.send(:warn_if_not_dg, short_name)
+      @client.send(:ensure_initialized!)
+      @client.send(:call_dg_tool, "data-grout/#{short_name}", params)
+    end
+  end
+end

data/lib/datagrout_conduit/namespaces/ephemerals.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module DatagroutConduit
+  class EphemeralsNamespace
+    def initialize(client)
+      @client = client
+    end
+
+    def list(params = {})
+      dg_call("ephemerals.list", "data-grout/ephemerals.list", params)
+    end
+
+    def inspect(cache_ref)
+      dg_call("ephemerals.inspect", "data-grout/ephemerals.inspect", { "cache_ref" => cache_ref })
+    end
+
+    private
+
+    def dg_call(label, tool_name, params)
+      @client.send(:warn_if_not_dg, label)
+      @client.send(:ensure_initialized!)
+      @client.send(:call_dg_tool, tool_name, params)
+    end
+  end
+end

data/lib/datagrout_conduit/namespaces/flow.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module DatagroutConduit
+  class FlowNamespace
+    def initialize(client)
+      @client = client
+    end
+
+    def run(plan, validate_ctc: true, save_as_skill: false, input_data: nil)
+      params = {
+        "plan" => plan,
+        "validate_ctc" => validate_ctc,
+        "save_as_skill" => save_as_skill
+      }
+      params["input_data"] = input_data if input_data
+      dg_call("flow.into", "data-grout/flow.into", params)
+    end
+
+    def route(branches:, payload: nil, cache_ref: nil, else_target: nil, **opts)
+      params = { "branches" => branches }
+      params["payload"] = payload if payload
+      params["cache_ref"] = cache_ref if cache_ref
+      params["else"] = else_target if else_target
+      dg_call("flow.route", "data-grout/flow.route", @client.send(:normalize_hash, opts).merge(params))
+    end
+
+    def request_approval(action:, details: nil, reason: nil, context: nil, **opts)
+      params = { "action" => action }.merge(@client.send(:normalize_hash, opts))
+      params["details"] = details if details
+      params["reason"] = reason if reason
+      params["context"] = context if context
+      dg_call("flow.request-approval", "data-grout/flow.request-approval", params)
+    end
+
+    def request_feedback(missing_fields:, reason:, current_data: nil, suggestions: nil, context: nil, **opts)
+      params = { "missing_fields" => missing_fields, "reason" => reason }.merge(@client.send(:normalize_hash, opts))
+      params["current_data"] = current_data if current_data
+      params["suggestions"] = suggestions if suggestions
+      params["context"] = context if context
+      dg_call("flow.request-feedback", "data-grout/flow.request-feedback", params)
+    end
+
+    def history(limit: 50, offset: 0, status: nil, refractions_only: false, **opts)
+      params = { "limit" => limit, "offset" => offset, "refractions_only" => refractions_only }.merge(@client.send(:normalize_hash, opts))
+      params["status"] = status if status
+      dg_call("inspect.execution-history", "data-grout/inspect.execution-history", params)
+    end
+
+    def details(execution_id:)
+      params = { "execution_id" => execution_id }
+      dg_call("inspect.execution-details", "data-grout/inspect.execution-details", params)
+    end
+
+    private
+
+    def dg_call(label, tool_name, params)
+      @client.send(:warn_if_not_dg, label)
+      @client.send(:ensure_initialized!)
+      @client.send(:call_dg_tool, tool_name, params)
+    end
+  end
+end

data/lib/datagrout_conduit/namespaces/logic.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module DatagroutConduit
+  class LogicNamespace
+    def initialize(client)
+      @client = client
+    end
+
+    def remember(statement: nil, facts: nil, tag: nil)
+      raise ArgumentError, "must provide statement or facts" unless statement || facts
+
+      params = {}
+      params["statement"] = statement if statement
+      params["facts"] = facts if facts
+      params["tag"] = tag if tag
+      dg_call("logic.remember", params)
+    end
+
+    def query(question: nil, patterns: nil, limit: nil)
+      raise ArgumentError, "must provide question or patterns" unless question || patterns
+
+      params = {}
+      params["question"] = question if question
+      params["patterns"] = patterns if patterns
+      params["limit"] = limit if limit
+      dg_call("logic.query", params)
+    end
+
+    def forget(handles: nil, pattern: nil)
+      raise ArgumentError, "must provide handles or pattern" unless handles || pattern
+
+      params = {}
+      params["handles"] = handles if handles
+      params["pattern"] = pattern if pattern
+      dg_call("logic.forget", params)
+    end
+
+    def constrain(rule:, tag: nil)
+      params = { "rule" => rule }
+      params["tag"] = tag if tag
+      dg_call("logic.constrain", params)
+    end
+
+    def reflect(entity: nil, summary_only: false)
+      params = { "summary_only" => summary_only }
+      params["entity"] = entity if entity
+      dg_call("logic.reflect", params)
+    end
+
+    def hydrate(params = {})
+      dg_call("logic.hydrate", params)
+    end
+
+    def export_cell(params = {})
+      dg_call("logic.export", params)
+    end
+
+    def import_cell(params = {})
+      dg_call("logic.import", params)
+    end
+
+    def tabulate(params = {})
+      dg_call("logic.tabulate", params)
+    end
+
+    def worlds(params = {})
+      dg_call("logic.worlds", params)
+    end
+
+    private
+
+    def dg_call(short_name, params)
+      @client.send(:warn_if_not_dg, short_name)
+      @client.send(:ensure_initialized!)
+      @client.send(:call_dg_tool, "data-grout/#{short_name}", params)
+    end
+  end
+end

data/lib/datagrout_conduit/namespaces/prism.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module DatagroutConduit
+  class PrismNamespace
+    def initialize(client)
+      @client = client
+    end
+
+    def refract(goal:, payload:, **opts)
+      params = { "goal" => goal, "payload" => payload }
+      params["verbose"] = opts[:verbose] if opts.key?(:verbose)
+      params["chart"] = opts[:chart] if opts.key?(:chart)
+      dg_call("prism.refract", params)
+    end
+
+    def chart(goal:, payload:, **opts)
+      params = { "goal" => goal, "payload" => payload }
+      params["format"] = opts[:format] if opts[:format]
+      params["chart_type"] = opts[:chart_type] if opts[:chart_type]
+      params["title"] = opts[:title] if opts[:title]
+      params["x_label"] = opts[:x_label] if opts[:x_label]
+      params["y_label"] = opts[:y_label] if opts[:y_label]
+      params["width"] = opts[:width] if opts[:width]
+      params["height"] = opts[:height] if opts[:height]
+      dg_call("prism.chart", params)
+    end
+
+    def render(goal:, payload: nil, format: "markdown", sections: nil, **opts)
+      params = { "goal" => goal, "format" => format }.merge(@client.send(:normalize_hash, opts))
+      params["payload"] = payload if payload
+      params["sections"] = sections if sections
+      dg_call("prism.render", params)
+    end
+
+    def export(content:, format:, style: nil, metadata: nil, **opts)
+      params = { "content" => content, "format" => format }.merge(@client.send(:normalize_hash, opts))
+      params["style"] = style if style
+      params["metadata"] = metadata if metadata
+      dg_call("prism.export", params)
+    end
+
+    def focus(data:, source_type:, target_type:, source_annotations: nil, target_annotations: nil, context: nil)
+      params = { "data" => data, "source_type" => source_type, "target_type" => target_type }
+      params["source_annotations"] = source_annotations if source_annotations
+      params["target_annotations"] = target_annotations if target_annotations
+      params["context"] = context if context
+      dg_call("prism.focus", params)
+    end
+
+    private
+
+    def dg_call(short_name, params)
+      @client.send(:warn_if_not_dg, short_name)
+      @client.send(:ensure_initialized!)
+      @client.send(:call_dg_tool, "data-grout/#{short_name}", params)
+    end
+  end
+end

data/lib/datagrout_conduit/namespaces/warden.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module DatagroutConduit
+  class WardenNamespace
+    def initialize(client)
+      @client = client
+    end
+
+    def canary(params = {})
+      dg_call("warden.canary", params)
+    end
+
+    def verify_intent(params = {})
+      dg_call("warden.intent", params)
+    end
+
+    def adjudicate(params = {})
+      dg_call("warden.adjudicate", params)
+    end
+
+    def ensemble(params = {})
+      dg_call("warden.ensemble", params)
+    end
+
+    private
+
+    def dg_call(short_name, params)
+      @client.send(:warn_if_not_dg, short_name)
+      @client.send(:ensure_initialized!)
+      @client.send(:call_dg_tool, "data-grout/#{short_name}", params)
+    end
+  end
+end

data/lib/datagrout_conduit/types.rb

@@ -90,6 +90,62 @@ module DatagroutConduit
     end
   end
 
+  # Extract DataGrout metadata from a tool-call result hash.
+  #
+  # Checks sources in priority order:
+  # 1. +result["_meta"]["datagrout"]+ — rich format
+  # 2. +result["_datagrout"]+ / +result["_meta"]+ — legacy
+  # 3. +result["_dg"]+ — compact inline (synthesized)
+  #
+  # Returns +nil+ when no metadata is found.
+  def self.extract_meta(result)
+    return nil unless result.is_a?(Hash)
+
+    # 1. Rich: _meta.datagrout (string or symbol keys)
+    rich = result.dig("_meta", "datagrout") || result.dig(:_meta, :datagrout)
+    if rich.is_a?(Hash) && (rich["receipt"] || rich[:receipt])
+      return ToolMeta.from_hash(rich.transform_keys(&:to_s))
+    end
+
+    # 2. Legacy: _datagrout or bare _meta (string or symbol keys)
+    %w[_datagrout _meta].each do |key|
+      legacy = result[key] || result[key.to_sym]
+      if legacy.is_a?(Hash) && (legacy["receipt"] || legacy[:receipt])
+        return ToolMeta.from_hash(legacy.transform_keys(&:to_s))
+      end
+    end
+
+    # 3. Compact: _dg (string or symbol keys)
+    dg = result["_dg"] || result[:_dg]
+    if dg.is_a?(Hash)
+      credits = dg["credits"] || {}
+      breakdown = {}
+      breakdown["premium"] = credits["premium"] if credits.key?("premium")
+      breakdown["llm"] = credits["llm"] if credits.key?("llm")
+
+      return ToolMeta.new(
+        receipt: Receipt.new(
+          receipt_id: nil,
+          timestamp: nil,
+          estimated_credits: (credits["estimated"] || 0.0).to_f,
+          actual_credits: (credits["charged"] || 0.0).to_f,
+          net_credits: (credits["charged"] || 0.0).to_f,
+          savings: 0.0,
+          savings_bonus: 0.0,
+          balance_after: credits["remaining"]&.to_f,
+          breakdown: breakdown,
+          byok: Byok.new(enabled: false, discount_applied: 0.0, discount_rate: 0.0)
+        ),
+        credit_estimate: nil
+      )
+    end
+
+    warn "[conduit] No DataGrout metadata found in tool result. " \
+         "Cost tracking data is unavailable. Enable 'Include DG Inline' " \
+         "or 'Include DataGrout Metadata' in your server settings."
+    nil
+  end
+
   DiscoveredTool = Struct.new(:name, :description, :input_schema, :score, :integration, :server, keyword_init: true) do
     def self.from_hash(hash)
       hash = hash.transform_keys(&:to_s)

data/lib/datagrout_conduit/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module DatagroutConduit
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/lib/datagrout_conduit.rb

@@ -11,6 +11,12 @@ require_relative "datagrout_conduit/registration"
 require_relative "datagrout_conduit/transport/base"
 require_relative "datagrout_conduit/transport/mcp"
 require_relative "datagrout_conduit/transport/jsonrpc"
+require_relative "datagrout_conduit/namespaces/prism"
+require_relative "datagrout_conduit/namespaces/logic"
+require_relative "datagrout_conduit/namespaces/warden"
+require_relative "datagrout_conduit/namespaces/deliverables"
+require_relative "datagrout_conduit/namespaces/ephemerals"
+require_relative "datagrout_conduit/namespaces/flow"
 require_relative "datagrout_conduit/client"
 
 module DatagroutConduit
@@ -28,26 +34,4 @@ module DatagroutConduit
       ENV.key?("CONDUIT_IS_DG")
   end
 
-  # Extract the DataGrout metadata block from a tool-call result.
-  #
-  # Checks +_meta.datagrout+ first (current format), then +_datagrout+,
-  # then falls back to +_meta+ for backward compatibility with older
-  # gateway responses.
-  #
-  # Returns nil when the result contains neither key (e.g. upstream servers
-  # that don't go through the DG gateway).
-  #
-  #   meta = DatagroutConduit.extract_meta(result)
-  #   meta.receipt.net_credits  #=> 1.5
-  #   meta.receipt.receipt_id   #=> "rcp_abc123"
-  def self.extract_meta(result)
-    return nil unless result.is_a?(Hash)
-
-    raw = result.dig("_meta", "datagrout") || result.dig(:_meta, :datagrout) ||
-          result["_datagrout"] || result[:_datagrout] ||
-          result["_meta"] || result[:_meta]
-    return nil if raw.nil?
-
-    ToolMeta.from_hash(raw)
-  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: datagrout-conduit
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - DataGrout
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-03-03 00:00:00.000000000 Z
+date: 2026-03-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
@@ -108,6 +108,12 @@ files:
 - lib/datagrout_conduit/client.rb
 - lib/datagrout_conduit/errors.rb
 - lib/datagrout_conduit/identity.rb
+- lib/datagrout_conduit/namespaces/deliverables.rb
+- lib/datagrout_conduit/namespaces/ephemerals.rb
+- lib/datagrout_conduit/namespaces/flow.rb
+- lib/datagrout_conduit/namespaces/logic.rb
+- lib/datagrout_conduit/namespaces/prism.rb
+- lib/datagrout_conduit/namespaces/warden.rb
 - lib/datagrout_conduit/oauth.rb
 - lib/datagrout_conduit/registration.rb
 - lib/datagrout_conduit/transport/base.rb