igniter 0.5.0 → 0.5.1

data/packages/igniter-sdk/lib/igniter/sdk.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require "igniter/core/errors"
+
+module Igniter
+  module SDK
+    Capability = Struct.new(:name, :entrypoint, :allowed_layers, :provides_capabilities, keyword_init: true)
+
+    class Error < Igniter::Error; end
+    class UnknownCapabilityError < Error; end
+    class LayerViolationError < Error; end
+
+    class << self
+      def register(name, entrypoint:, allowed_layers:, provides_capabilities: [])
+        capability = Capability.new(
+          name: name.to_sym,
+          entrypoint: entrypoint.to_s,
+          allowed_layers: Array(allowed_layers).map(&:to_sym).uniq.freeze,
+          provides_capabilities: Array(provides_capabilities).map(&:to_sym).uniq.sort.freeze
+        )
+
+        registry[capability.name] = capability
+      end
+
+      def fetch(name)
+        registry.fetch(name.to_sym)
+      rescue KeyError
+        available = registry.keys.sort.map(&:inspect).join(", ")
+        raise UnknownCapabilityError, "Unknown SDK capability #{name.inspect} (available: #{available})"
+      end
+
+      def capabilities(layer: nil)
+        values = registry.values
+        return values.sort_by(&:name) unless layer
+
+        values.select { |capability| capability.allowed_layers.include?(layer.to_sym) }.sort_by(&:name)
+      end
+
+      def activate!(*names, layer:)
+        resolved_layer = layer.to_sym
+
+        names.flatten.each do |name|
+          capability = fetch(name)
+          unless capability.allowed_layers.include?(resolved_layer)
+            raise LayerViolationError,
+                  "SDK capability #{capability.name.inspect} is not allowed for layer #{resolved_layer.inspect} " \
+                  "(allowed: #{capability.allowed_layers.map(&:inspect).join(', ')})"
+          end
+
+          require capability.entrypoint
+          activated_capabilities << capability.name unless activated?(capability.name)
+        end
+
+        true
+      end
+
+      def activated?(name)
+        activated_capabilities.include?(name.to_sym)
+      end
+
+      def activated_capabilities
+        @activated_capabilities ||= []
+      end
+
+      def reset!
+        @activated_capabilities = []
+      end
+
+      def register_builtin_capabilities!
+        register(:ai, entrypoint: "igniter/ai", allowed_layers: %i[app server cluster], provides_capabilities: %i[network external_api])
+        register(:agents, entrypoint: "igniter/agents", allowed_layers: %i[app server cluster], provides_capabilities: [])
+        register(:channels, entrypoint: "igniter/sdk/channels", allowed_layers: %i[app server cluster], provides_capabilities: %i[messaging network])
+        register(:tools, entrypoint: "igniter/sdk/tools", allowed_layers: %i[app server cluster], provides_capabilities: %i[filesystem])
+        register(:data, entrypoint: "igniter/sdk/data", allowed_layers: %i[core app server cluster], provides_capabilities: %i[cache database])
+      end
+
+      private
+
+      def registry
+        @registry ||= {}
+      end
+    end
+
+    register_builtin_capabilities!
+  end
+end

data/packages/igniter-sdk/lib/igniter-sdk.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative "igniter/sdk"

data/packages/igniter-server/README.md

@@ -0,0 +1,9 @@
+# igniter-server
+
+Local monorepo gem for Igniter's built-in HTTP server transport layer.
+
+Docs:
+
+- [Guide](../../docs/guide/README.md)
+- [App guide](../../docs/guide/app.md)
+- [Dev](../../docs/dev/README.md)

data/packages/igniter-server/lib/igniter/server/agent_session_store.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Server
+    class AgentSessionStore
+      STORAGE_GRAPH = "__igniter_server_agent_sessions__"
+      ID_PREFIX = "agent-session:"
+
+      def initialize(store: nil)
+        @store = store
+        @sessions = {}
+        @mutex = Mutex.new
+      end
+
+      def save(session)
+        normalized = normalize_session(session)
+        if runtime_store
+          runtime_store.save(
+            {
+              execution_id: storage_id(normalized.token),
+              graph: STORAGE_GRAPH,
+              token: normalized.token,
+              session: normalized.to_h
+            },
+            graph: STORAGE_GRAPH,
+            correlation: { token: normalized.token.to_s }
+          )
+        else
+          @mutex.synchronize { @sessions[normalized.token] = deep_copy(normalized.to_h) }
+        end
+        normalized
+      end
+
+      def fetch(token)
+        data =
+          if runtime_store
+            snapshot = runtime_store.fetch(storage_id(token))
+            snapshot[:session] || snapshot["session"]
+          else
+            @mutex.synchronize { deep_copy(@sessions.fetch(token.to_s)) }
+          end
+        Igniter::Runtime::AgentSession.from_h(data)
+      rescue KeyError
+        raise Igniter::ResolutionError, "No agent session found for token '#{token}'"
+      end
+
+      def delete(token)
+        if runtime_store
+          runtime_store.delete(storage_id(token))
+        else
+          @mutex.synchronize { @sessions.delete(token.to_s) }
+        end
+      end
+
+      def exist?(token)
+        if runtime_store
+          runtime_store.exist?(storage_id(token))
+        else
+          @mutex.synchronize { @sessions.key?(token.to_s) }
+        end
+      end
+
+      def list_tokens
+        if runtime_store
+          runtime_store.list_all(graph: STORAGE_GRAPH).map { |id| extract_token(id) }
+        else
+          @mutex.synchronize { @sessions.keys.dup }
+        end
+      end
+
+      private
+
+      def runtime_store
+        resolved = @store.respond_to?(:call) ? @store.call : @store
+        resolved if resolved&.respond_to?(:save) && resolved.respond_to?(:fetch)
+      end
+
+      def normalize_session(session)
+        return session if session.is_a?(Igniter::Runtime::AgentSession)
+
+        data = session.respond_to?(:to_h) ? session.to_h : session
+        Igniter::Runtime::AgentSession.from_h(data)
+      end
+
+      def storage_id(token)
+        "#{ID_PREFIX}#{token}"
+      end
+
+      def extract_token(storage_id)
+        storage_id.to_s.start_with?(ID_PREFIX) ? storage_id.to_s.delete_prefix(ID_PREFIX) : storage_id.to_s
+      end
+
+      def deep_copy(value)
+        Marshal.load(Marshal.dump(value))
+      end
+    end
+  end
+end

data/packages/igniter-server/lib/igniter/server/agent_transport.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Server
+    # HTTP transport for remotely routed agent nodes.
+    class AgentTransport < Igniter::Runtime::AgentTransport
+      def session_lifecycle?
+        true
+      end
+
+      def call(route:, node:, inputs:, execution: nil) # rubocop:disable Lint/UnusedMethodArgument
+        client = Client.new(route.url, timeout: node.timeout)
+        response = client.call_agent(
+          via: node.agent_name,
+          message: node.message_name,
+          inputs: inputs,
+          timeout: node.timeout,
+          reply_mode: node.reply_mode
+        )
+
+        normalize_response(response)
+      rescue Client::ConnectionError => error
+        raise ResolutionError, "Cannot reach #{route.url}: #{error.message}"
+      end
+
+      def cast(route:, node:, inputs:, execution: nil) # rubocop:disable Lint/UnusedMethodArgument
+        client = Client.new(route.url, timeout: node.timeout)
+        response = client.cast_agent(
+          via: node.agent_name,
+          message: node.message_name,
+          inputs: inputs,
+          timeout: node.timeout
+        )
+
+        normalize_response(response)
+      rescue Client::ConnectionError => error
+        raise ResolutionError, "Cannot reach #{route.url}: #{error.message}"
+      end
+
+      def continue_session(route:, session:, payload:, execution: nil, trace: nil, token: nil, waiting_on: nil, request: nil, reply: nil, phase: nil) # rubocop:disable Metrics/ParameterLists, Lint/UnusedMethodArgument
+        client = Client.new(route.url, timeout: 5)
+        response = client.continue_agent_session(
+          token: session.token,
+          session: session.to_h,
+          payload: payload,
+          trace: trace,
+          next_token: token,
+          waiting_on: waiting_on,
+          request: request,
+          reply: reply,
+          phase: phase
+        )
+
+        normalize_response(response)
+      rescue Client::ConnectionError => error
+        raise ResolutionError, "Cannot reach #{route.url}: #{error.message}"
+      end
+
+      def resume_session(route:, session:, execution: nil, value: nil) # rubocop:disable Lint/UnusedMethodArgument
+        return nil if value.nil?
+
+        client = Client.new(route.url, timeout: 5)
+        response = client.resume_agent_session(
+          token: session.token,
+          session: session.to_h,
+          value: value
+        )
+
+        normalize_response(response)
+      rescue Client::ConnectionError => error
+        raise ResolutionError, "Cannot reach #{route.url}: #{error.message}"
+      end
+
+      private
+
+      def normalize_response(response)
+        normalized = response.dup
+        deferred = response[:deferred_result]
+        return normalized unless deferred.is_a?(Hash) && !deferred.empty?
+
+        normalized[:deferred_result] = Igniter::Runtime::DeferredResult.build(
+          token: value_from(deferred, :token),
+          payload: value_from(deferred, :payload) || {},
+          source_node: value_from(deferred, :source_node),
+          waiting_on: value_from(deferred, :waiting_on)
+        )
+        normalized
+      end
+
+      def value_from(hash, key)
+        hash[key] || hash[key.to_s]
+      end
+    end
+  end
+end

data/packages/igniter-server/lib/igniter/server/app_host.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require "igniter/app/app_host_pack"

data/{lib → packages/igniter-server/lib}/igniter/server/client.rb

@@ -6,7 +6,7 @@ require "uri"
 
 module Igniter
   module Server
-    # HTTP client for calling remote igniter-server nodes.
+    # HTTP client for calling remote igniter-stack nodes.
     # Uses only stdlib (Net::HTTP + JSON), no external gems required.
     class Client # rubocop:disable Metrics/ClassLength
       class Error < Igniter::Server::Error; end
@@ -51,14 +51,77 @@ module Igniter
         get("/v1/health")
       end
 
+      def call_agent(via:, message:, inputs: {}, timeout: 5, reply_mode: nil)
+        response = post(
+          "/v1/agents/#{uri_encode(via)}/messages/#{uri_encode(message)}/call",
+          {
+            inputs: inputs,
+            timeout: timeout,
+            reply_mode: reply_mode
+          }.compact
+        )
+        symbolize_agent_response(response)
+      end
+
+      def cast_agent(via:, message:, inputs: {}, timeout: 5)
+        response = post(
+          "/v1/agents/#{uri_encode(via)}/messages/#{uri_encode(message)}/cast",
+          {
+            inputs: inputs,
+            timeout: timeout
+          }
+        )
+        symbolize_agent_response(response)
+      end
+
+      def continue_agent_session(token:, session:, payload: {}, trace: nil, next_token: nil, waiting_on: nil, request: nil, reply: nil, phase: nil)
+        response = post(
+          "/v1/agent-sessions/#{uri_encode(token)}/continue",
+          {
+            session: session,
+            payload: payload,
+            trace: trace,
+            token: next_token,
+            waiting_on: waiting_on,
+            request: request,
+            reply: reply,
+            phase: phase
+          }.compact
+        )
+        symbolize_agent_response(response)
+      end
+
+      def resume_agent_session(token:, session:, value: nil, trace: nil, reply: nil)
+        body = {
+          session: session,
+          trace: trace,
+          reply: reply
+        }.compact
+        body[:value] = value if !value.nil? || body.empty?
+
+        response = post(
+          "/v1/agent-sessions/#{uri_encode(token)}/resume",
+          body
+        )
+        symbolize_agent_response(response)
+      end
+
       # Fetch peer manifest: peer_name, capabilities, contracts, url.
       def manifest
         response = get("/v1/manifest")
         {
           peer_name: response["peer_name"],
+          node_id: response["node_id"],
+          algorithm: response["algorithm"],
+          public_key: response["public_key"],
           capabilities: (response["capabilities"] || []).map(&:to_sym),
+          tags: (response["tags"] || []).map(&:to_sym),
+          metadata: response["metadata"] || {},
           contracts: response["contracts"] || [],
-          url: response["url"]
+          url: response["url"],
+          capability_attestation: response["capability_attestation"],
+          signed_at: response["signed_at"],
+          signature: response["signature"]
         }
       end
 
@@ -69,15 +132,29 @@ module Igniter
           {
             name: p["name"],
             url: p["url"],
-            capabilities: Array(p["capabilities"]).map(&:to_sym)
+            capabilities: Array(p["capabilities"]).map(&:to_sym),
+            tags: Array(p["tags"]).map(&:to_sym),
+            metadata: p["metadata"] || {}
           }
         end
       end
 
       # Register this node as a peer on the remote node.
-      def register_peer(name:, url:, capabilities: [])
-        post("/v1/mesh/peers",
-             { "name" => name, "url" => url, "capabilities" => capabilities.map(&:to_s) })
+      def register_peer(name: nil, url: nil, capabilities: [], tags: [], metadata: {}, manifest: nil)
+        body = if manifest
+                 candidate = manifest.respond_to?(:to_h) ? manifest.to_h : manifest
+                 Hash(candidate)
+               else
+                 {
+                   "name" => name,
+                   "url" => url,
+                   "capabilities" => capabilities.map(&:to_s),
+                   "tags" => tags.map(&:to_s),
+                   "metadata" => metadata
+                 }
+               end
+
+        post("/v1/mesh/peers", body)
       end
 
       # Remove a peer registration from the remote node. Best-effort.
@@ -152,6 +229,19 @@ module Igniter
         }
       end
 
+      def symbolize_agent_response(hash)
+        {
+          status: hash["status"]&.to_sym,
+          output: hash["output"],
+          payload: symbolize_keys(hash["payload"] || {}),
+          deferred_result: (symbolize_keys(hash["deferred_result"]) if hash.key?("deferred_result")),
+          agent_trace: symbolize_keys(hash["agent_trace"] || {}),
+          agent_session: (symbolize_keys(hash["agent_session"]) if hash.key?("agent_session")),
+          error: hash["error"],
+          message: hash["message"]
+        }.compact
+      end
+
       def symbolize_keys(hash)
         return hash unless hash.is_a?(Hash)
 

data/packages/igniter-server/lib/igniter/server/config.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Server
+    class Config
+      attr_accessor :host, :port, :store, :logger,
+                    :metrics_collector, :log_format, :drain_timeout,
+                    :peer_name, :peer_capabilities, :peer_tags, :peer_metadata, :peer_identity, :peer_trust_store, :custom_routes,
+                    :before_request_hooks, :after_request_hooks, :around_request_hooks, :after_start_hooks,
+                    :agent_session_store
+      attr_reader   :registry
+
+      def initialize
+        @host              = "0.0.0.0"
+        @port              = 4567
+        @store             = Igniter::Runtime::Stores::MemoryStore.new
+        @agent_session_store = Igniter::Server::AgentSessionStore.new(store: -> { @store })
+        @registry          = Registry.new
+        @logger            = nil
+        @metrics_collector = nil
+        @log_format        = :text
+        @drain_timeout     = 30
+        @peer_name         = nil
+        @peer_capabilities = []
+        @peer_tags         = []
+        @peer_metadata     = {}
+        @peer_identity     = nil
+        @peer_trust_store  = nil
+        @custom_routes     = []
+        @before_request_hooks = []
+        @after_request_hooks = []
+        @around_request_hooks = []
+        @after_start_hooks = []
+      end
+
+      def ensure_peer_identity!
+        load_cluster_support!
+        @peer_identity ||= Igniter::Cluster::Identity::NodeIdentity.generate(node_id: @peer_name || "anonymous-node")
+      end
+
+      def peer_trust_store
+        @peer_trust_store ||= begin
+          load_cluster_support!
+          Igniter::Cluster::Trust::TrustStore.new
+        end
+      end
+
+      def register(name, contract_class)
+        @registry.register(name, contract_class)
+        self
+      end
+
+      def contracts=(hash)
+        hash.each { |name, klass| register(name.to_s, klass) }
+      end
+
+      private
+
+      def load_cluster_support!
+        return if defined?(Igniter::Cluster::Identity::NodeIdentity) &&
+          defined?(Igniter::Cluster::Trust::TrustStore)
+
+        require "igniter/cluster"
+      rescue LoadError => e
+        raise LoadError,
+              "Igniter::Server cluster identity support requires `igniter/cluster` (#{e.message})"
+      end
+    end
+  end
+end

data/packages/igniter-server/lib/igniter/server/handlers/agent_message_handler.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Server
+    module Handlers
+      class AgentMessageHandler < Base
+        def initialize(registry, store, session_store:, mode:) # rubocop:disable Lint/UnusedMethodArgument
+          super(registry, store)
+          @session_store = session_store
+          @mode = mode.to_sym
+        end
+
+        private
+
+        def handle(params:, body:)
+          require "igniter/agent"
+
+          node = build_node(params, body)
+          adapter = Igniter::Runtime::RegistryAgentAdapter.new
+          response =
+            if @mode == :cast
+              adapter.cast(node: node, inputs: symbolize_inputs(body["inputs"] || {}))
+            else
+              adapter.call(node: node, inputs: symbolize_inputs(body["inputs"] || {}))
+            end
+
+          persist_pending_session!(response, node) if response[:status] == :pending
+
+          json_ok(serialize_agent_response(response))
+        end
+
+        def build_node(params, body)
+          reply_mode =
+            if @mode == :cast
+              :none
+            else
+              raw = body["reply_mode"]
+              raw ? raw.to_sym : :deferred
+            end
+
+          Igniter::Model::AgentNode.new(
+            id: "server-agent:#{params[:via]}:#{params[:message]}:#{@mode}",
+            name: :"server_#{params[:via]}_#{params[:message]}_#{@mode}",
+            agent_name: params[:via],
+            message_name: params[:message],
+            input_mapping: symbolize_inputs(body["inputs"] || {}).transform_keys(&:to_sym),
+            timeout: body["timeout"] || 5,
+            mode: @mode,
+            reply_mode: reply_mode
+          )
+        end
+
+        def serialize_agent_response(response)
+          data = {
+            status: response[:status].to_s,
+            output: to_json_value(response[:output]),
+            payload: to_json_value(response[:payload]),
+            agent_trace: to_json_value(response[:agent_trace]),
+            agent_session: to_json_value(response[:agent_session]),
+            message: response[:message]
+          }
+
+          if response[:deferred_result]
+            data[:deferred_result] = {
+              token: response[:deferred_result].token,
+              source_node: response[:deferred_result].source_node,
+              waiting_on: response[:deferred_result].waiting_on,
+              payload: to_json_value(response[:deferred_result].payload)
+            }
+          end
+
+          data[:error] = to_json_value(response[:error]) if response[:error]
+          data.compact
+        end
+
+        def persist_pending_session!(response, node)
+          session = normalize_pending_session(response, node)
+          return unless session
+
+          response[:agent_session] = @session_store.save(session).to_h
+        end
+
+        def normalize_pending_session(response, node)
+          raw_session = response[:agent_session] || response[:session]
+          return Igniter::Runtime::AgentSession.from_h(raw_session) if raw_session
+
+          deferred = response[:deferred_result]
+          return nil unless deferred
+
+          Igniter::Runtime::AgentSession.new(
+            token: deferred.token,
+            node_name: deferred.source_node || node.name,
+            agent_name: node.agent_name,
+            message_name: node.message_name,
+            mode: node.mode,
+            reply_mode: node.reply_mode,
+            waiting_on: deferred.waiting_on || deferred.source_node || node.name,
+            source_node: deferred.source_node || node.name,
+            trace: response[:agent_trace],
+            payload: deferred.payload || response[:payload] || {},
+            ownership: :remote
+          )
+        end
+      end
+    end
+  end
+end