kairos-chain 3.14.1 → 3.15.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: baa3c9211947b4332c06aaa76869e817851ba5e314ada6045477c0bd8f87e7ff
-  data.tar.gz: 4fa1dc54890125ffa1bf0be7d553f83f0deb536278776959f586d17dfcaff7d8
+  metadata.gz: de33a990a4ade8e91533b4a596e0f9e73fcd921c68af62cc9daa30173879234a
+  data.tar.gz: 29930e999d710a29626a4a22ed8f49f66dafe2b36f675be1e04bd308a76c75ba
 SHA512:
-  metadata.gz: e82e3292dfeed48d2326e3e118d222f23b0b96547841f9ae5f937dae4ed74b61b012168e9b69a64a8f6870f5a04c70574fe36cbef8ac242a73318b36f4171ba8
-  data.tar.gz: cb89a2cbe23dd57bf62b764dcf9bc382c4c1d84dc6bcc5e622673b50f77a2e3074b1f2a703a088f837fd06ce8a41f8234c21881e3935b94c6e5155c2c96751d4
+  metadata.gz: 3bb7aa9b8e4ac13aaa84b126277cdefb3ca479a0aee831e159da89881605061dd2f16aa2efdd11cc2c4be28736d295d90c65c6e74be88e41c7788ee000fc8341
+  data.tar.gz: b073833ea3eb15699e57078accac4eed96a3c30088382c9fa310cb1847f0bd6ea41392d1d9ea269ff9e1406d49ddd793b8f0b488bc6369144ce52b7c46812340

data/CHANGELOG.md

@@ -4,6 +4,52 @@ All notable changes to the `kairos-chain` gem will be documented in this file.
 
 This project follows [Semantic Versioning](https://semver.org/).
 
+## [3.15.0] - 2026-04-15
+
+### Fixed
+
+- **PlaceClient browse drops tags** — `PlaceClient#browse` silently discarded the
+  `tags` parameter when building query params. Tag-filtered browse and federate
+  now work correctly.
+- **Silent error swallowing in 5 MMP tools** — `meeting_browse`, `meeting_deposit`,
+  `meeting_get_skill_details`, `meeting_acquire_skill`, and `meeting_federate`
+  used raw `Net::HTTP` with `rescue StandardError; nil`, hiding connection errors,
+  auth failures, and server errors. All 5 tools now use `PlaceClient` with
+  structured error reporting.
+- **Wrong auth token for /meeting/v1/* endpoints** — `meeting_get_skill_details`
+  and `meeting_acquire_skill` (peer path) sent the Place session token to
+  `/meeting/v1/*` endpoints instead of the meeting session token. Token routing
+  now matches endpoint prefix: `/place/v1/*` uses `session_token`,
+  `/meeting/v1/*` uses `meeting_session_token`.
+
+### Added
+
+- **PlaceClient.reconnect** — class method for restoring client state from saved
+  connection without re-registration. Replaces `instance_variable_set` pattern.
+- **PlaceClient new methods** — `deposit`, `get_skill_details`, `get_skill_content`,
+  `request_skill_content`, `place_info` (unauthenticated).
+- **Response adapters** — A1 (Place skill content), A2 (peer skill content with
+  nested payload unwrap), A3 (skill details with metadata envelope unwrap and
+  error/not_found distinction).
+- **Expanded network error handling** — `PlaceClient` now catches `SocketError`,
+  `Net::ReadTimeout`, `OpenSSL::SSL::SSLError`, `Errno::ECONNRESET`, `Errno::EPIPE`
+  in addition to `Errno::ECONNREFUSED` and `Net::OpenTimeout`.
+- **PlaceClient.parse_response preserves server error details** — non-success HTTP
+  responses now retain full server body (`:reasons`, `:status`, etc.) instead of
+  wrapping into a generic `{ error: "HTTP 4xx" }`.
+
+### Removed
+
+- **Dead code** — `get_details_relay` and `get_skill_from_relay` (unused relay
+  path methods) removed from `meeting_get_skill_details` and `meeting_acquire_skill`.
+
+### Review
+
+- Design: 3 rounds × 3 LLMs (Claude Opus 4.6, Codex GPT-5.4, Cursor Composer-2)
+- Implementation: 1 round × 3 LLMs
+- Key findings: browse tags bug (3/3), response format contract (3/3),
+  token routing (Codex FAIL → resolved), adapter key mismatch (Claude HIGH → resolved)
+
 ## [3.14.1] - 2026-04-12
 
 ### Fixed

data/lib/kairos_mcp/anthropic_skill_parser.rb

@@ -78,7 +78,7 @@ module KairosMcp
           description: frontmatter['description'],
           version: frontmatter['version'],
           layer: frontmatter['layer'],
-          tags: frontmatter['tags'] || [],
+          tags: normalize_tags(frontmatter['tags']),
           content: body.strip,
           frontmatter: frontmatter,
           base_path: skill_dir,
@@ -204,6 +204,14 @@ module KairosMcp
 
       private
 
+      def normalize_tags(tags)
+        case tags
+        when Array then tags
+        when String then tags.split(',').map(&:strip).reject(&:empty?)
+        else []
+        end
+      end
+
       def find_md_file(skill_dir)
         # First try to find a file with the same name as the directory
         skill_name = File.basename(skill_dir)

data/lib/kairos_mcp/version.rb

@@ -1,4 +1,4 @@
 module KairosMcp
-  VERSION = "3.14.1"
+  VERSION = "3.15.0"
   CHANGELOG_URL = "https://github.com/masaomi/KairosChain_2026/blob/main/CHANGELOG.md"
 end

data/templates/skillsets/mmp/lib/mmp/place_client.rb

@@ -11,6 +11,12 @@ module MMP
     DEFAULT_MAX_SESSION_MINUTES = 60
     DEFAULT_WARN_AFTER_INTERACTIONS = 50
 
+    NETWORK_ERRORS = [
+      Errno::ECONNREFUSED, Errno::ECONNRESET, Errno::EPIPE,
+      Net::OpenTimeout, Net::ReadTimeout,
+      SocketError, OpenSSL::SSL::SSLError
+    ].freeze
+
     def initialize(place_url:, identity:, timeout: 10, crypto: nil, keypair_path: nil, config: {})
       @place_url = place_url.chomp('/')
       @identity = identity
@@ -26,6 +32,15 @@ module MMP
       @peer_public_keys = {}
     end
 
+    # Reconnect using saved connection state (no re-registration)
+    def self.reconnect(place_url:, identity:, session_token:, agent_id: nil, timeout: 10, config: {})
+      client = new(place_url: place_url, identity: identity, timeout: timeout, config: config)
+      client.instance_variable_set(:@bearer_token, session_token)
+      client.instance_variable_set(:@agent_id, agent_id)
+      client.instance_variable_set(:@connected, true)
+      client
+    end
+
     def connect
       result = register
       if result && result[:agent_id]
@@ -88,10 +103,36 @@ module MMP
     end
 
     def browse(type: nil, search: nil, tags: nil, limit: nil)
-      params = {}; params[:type] = type if type; params[:search] = search if search; params[:limit] = limit if limit
+      params = {}
+      params[:type] = type if type
+      params[:search] = search if search
+      params[:tags] = tags.is_a?(Array) ? tags.join(',') : tags if tags
+      params[:limit] = limit if limit
       get('/place/v1/board/browse', params)
     end
 
+    def deposit(skill)
+      post('/place/v1/deposit', skill)
+    end
+
+    def get_skill_details(skill_id:)
+      get('/meeting/v1/skill_details', { skill_id: skill_id })
+    end
+
+    def get_skill_content(skill_id:, owner: nil)
+      params = {}
+      params[:owner] = owner if owner
+      get("/place/v1/skill_content/#{URI.encode_www_form_component(skill_id)}", params)
+    end
+
+    def request_skill_content(skill_id:)
+      post('/meeting/v1/skill_content', { skill_id: skill_id })
+    end
+
+    def place_info
+      get_unauthenticated('/place/v1/info')
+    end
+
     def withdraw(skill_id:, reason:)
       delete("/place/v1/deposit/#{URI.encode_www_form_component(skill_id)}", { reason: reason })
     end
@@ -160,7 +201,20 @@ module MMP
       response = http.request(req)
       @interaction_count += 1
       parse_response(response)
-    rescue Errno::ECONNREFUSED, Net::OpenTimeout => e
+    rescue *NETWORK_ERRORS => e
+      { error: "Connection failed: #{e.message}" }
+    end
+
+    def get_unauthenticated(path, params = {})
+      uri = URI.parse("#{@place_url}#{path}")
+      uri.query = URI.encode_www_form(params) unless params.empty?
+      http = Net::HTTP.new(uri.host, uri.port); http.open_timeout = @timeout; http.read_timeout = @timeout
+      http.use_ssl = (uri.scheme == 'https')
+      req = Net::HTTP::Get.new(uri)
+      response = http.request(req)
+      @interaction_count += 1
+      parse_response(response)
+    rescue *NETWORK_ERRORS => e
       { error: "Connection failed: #{e.message}" }
     end
 
@@ -186,15 +240,20 @@ module MMP
       req.body = JSON.generate(body) if body
       @interaction_count += 1
       parse_response(http.request(req))
-    rescue Errno::ECONNREFUSED, Net::OpenTimeout => e
+    rescue *NETWORK_ERRORS => e
       { error: "Connection failed: #{e.message}" }
     end
 
     def parse_response(response)
       data = JSON.parse(response.body, symbolize_names: true)
-      response.is_a?(Net::HTTPSuccess) ? data : { error: data[:error] || "HTTP #{response.code}" }
+      if response.is_a?(Net::HTTPSuccess)
+        data
+      else
+        data[:error] ||= "HTTP #{response.code}"
+        data
+      end
     rescue JSON::ParserError
-      { error: "Invalid JSON response" }
+      { error: "Invalid JSON response (HTTP #{response.code})" }
     end
   end
 end

data/templates/skillsets/mmp/tools/meeting_acquire_skill.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'net/http'
-require 'uri'
 require 'json'
 require 'yaml'
 require 'digest'
@@ -52,11 +50,6 @@ module KairosMcp
             owner_agent_id = arguments['owner_agent_id']
             save_layer = arguments['save_to_layer'] || 'L1'
 
-            config = ::MMP.load_config
-            unless config['enabled']
-              return text_content(JSON.pretty_generate({ error: 'Meeting Protocol is disabled' }))
-            end
-
             connection = load_connection_state
             unless connection
               return text_content(JSON.pretty_generate({ error: 'Not connected', hint: 'Use meeting_connect first' }))
@@ -64,22 +57,30 @@ module KairosMcp
 
             begin
               url = connection['url'] || connection[:url]
-              token = connection['session_token'] || connection[:session_token]
 
               if peer_id
-                # Existing flow: acquire from specific peer
+                # Peer direct path: /meeting/v1/skill_content
                 peer = find_peer(connection, peer_id)
                 unless peer
                   return text_content(JSON.pretty_generate({ error: "Peer not found: #{peer_id}" }))
                 end
                 endpoint = peer['endpoint'] || peer[:endpoint]
                 target = endpoint || url
-                content_result = get_skill_direct(target, skill_id, bearer_token: token)
+
+                meeting_client = build_meeting_client(url_override: target)
+                return meeting_client if meeting_client.is_a?(Array)
+
+                raw = meeting_client.request_skill_content(skill_id: skill_id)
+                content_result = adapt_peer_skill_content(raw, skill_id)
                 source_id = peer_id
                 source_name = peer['name'] || peer[:name] || peer_id
               else
-                # A案: acquire from Place deposits
-                content_result = get_skill_from_place(url, skill_id, owner_agent_id: owner_agent_id, bearer_token: token)
+                # Place deposit path: /place/v1/skill_content/:id
+                place_client = build_place_client
+                return place_client if place_client.is_a?(Array)
+
+                raw = place_client.get_skill_content(skill_id: skill_id, owner: owner_agent_id)
+                content_result = adapt_place_skill_content(raw, skill_id)
                 source_id = content_result[:depositor_id] || owner_agent_id || 'place'
                 source_name = source_id
               end
@@ -155,10 +156,89 @@ module KairosMcp
             (connection['peers'] || connection[:peers] || []).find { |p| (p['agent_id'] || p[:agent_id]) == peer_id }
           end
 
+          # Build PlaceClient with session_token for /place/v1/* endpoints
+          def build_place_client(timeout: 10)
+            config = ::MMP.load_config
+            unless config['enabled']
+              return text_content(JSON.pretty_generate({ error: 'Meeting Protocol is disabled' }))
+            end
+            connection = load_connection_state
+            unless connection
+              return text_content(JSON.pretty_generate({ error: 'Not connected', hint: 'Use meeting_connect first' }))
+            end
+            url = connection['url'] || connection[:url]
+            token = connection['session_token'] || connection[:session_token]
+            agent_id = connection['agent_id'] || connection[:agent_id]
+            identity = ::MMP::Identity.new(config: config)
+            ::MMP::PlaceClient.reconnect(
+              place_url: url, identity: identity,
+              session_token: token, agent_id: agent_id, timeout: timeout
+            )
+          end
+
+          # Build PlaceClient with meeting_session_token for /meeting/v1/* endpoints
+          def build_meeting_client(url_override: nil, timeout: 10)
+            config = ::MMP.load_config
+            unless config['enabled']
+              return text_content(JSON.pretty_generate({ error: 'Meeting Protocol is disabled' }))
+            end
+            connection = load_connection_state
+            unless connection
+              return text_content(JSON.pretty_generate({ error: 'Not connected', hint: 'Use meeting_connect first' }))
+            end
+            url = url_override || connection['url'] || connection[:url]
+            token = connection['meeting_session_token'] || connection[:meeting_session_token]
+            unless token
+              return text_content(JSON.pretty_generate({
+                error: 'No meeting session token',
+                hint: 'meeting_connect may have failed the /meeting/v1/introduce handshake. Reconnect.'
+              }))
+            end
+            identity = ::MMP::Identity.new(config: config)
+            ::MMP::PlaceClient.reconnect(
+              place_url: url, identity: identity,
+              session_token: token, timeout: timeout
+            )
+          end
+
+          # Adapter A1: Place deposit skill content
+          def adapt_place_skill_content(raw, skill_id)
+            if raw[:error]
+              { success: false, error: raw[:error] }
+            else
+              {
+                success: true,
+                name: raw[:name] || skill_id,
+                skill_name: raw[:name] || skill_id,
+                format: raw[:format] || 'markdown',
+                content: raw[:content],
+                content_hash: raw[:content_hash],
+                size_bytes: raw[:content]&.bytesize || 0,
+                depositor_id: raw[:depositor_id],
+                trust_notice: raw[:trust_notice]
+              }
+            end
+          end
+
+          # Adapter A2: Peer direct skill content
+          def adapt_peer_skill_content(raw, skill_id)
+            if raw[:error]
+              { success: false, error: raw[:error] }
+            else
+              payload = raw.dig(:message, :payload) || raw[:payload] || raw
+              {
+                success: true,
+                skill_name: payload[:skill_name] || skill_id,
+                format: payload[:format] || 'markdown',
+                content: payload[:content],
+                content_hash: payload[:content_hash],
+                size_bytes: payload[:content]&.bytesize || 0
+              }
+            end
+          end
+
           MAX_TRUSTED_PEERS = 100
 
-          # Save or update a trusted peer in L1 knowledge.
-          # Returns true on success, false on failure.
           def save_trusted_peer(agent_id:, name:, place_url:, skill_acquired:)
             dir = File.join(KairosMcp.data_dir, 'knowledge', 'trusted_peers')
             FileUtils.mkdir_p(dir)
@@ -167,7 +247,6 @@ module KairosMcp
 
             peers = load_trusted_peers_data(filepath)
 
-            # Find or create peer entry
             existing = peers.find { |p| p['agent_id'] == agent_id }
             if existing
               existing['name'] = name
@@ -189,7 +268,6 @@ module KairosMcp
               }
             end
 
-            # LRU eviction: keep most recently interacted peers
             if peers.size > MAX_TRUSTED_PEERS
               peers = peers.sort_by { |p| p['last_interaction'] || '' }.last(MAX_TRUSTED_PEERS)
             end
@@ -222,68 +300,6 @@ module KairosMcp
             content = "---\n#{frontmatter.to_yaml}---\n\n# Trusted Peers\n\nPeers from whom skills were successfully acquired.\nAuto-managed by meeting_acquire_skill. Max #{MAX_TRUSTED_PEERS} entries (LRU).\n"
             File.write(filepath, content)
           end
-
-          # Acquire from Place's deposited skills (A案)
-          def get_skill_from_place(url, skill_id, owner_agent_id: nil, bearer_token: nil)
-            path = "/place/v1/skill_content/#{URI.encode_www_form_component(skill_id)}"
-            path += "?owner=#{URI.encode_www_form_component(owner_agent_id)}" if owner_agent_id
-            uri = URI.parse("#{url}#{path}")
-            http = Net::HTTP.new(uri.host, uri.port); http.use_ssl = (uri.scheme == 'https')
-            http.open_timeout = 5; http.read_timeout = 10
-            req = Net::HTTP::Get.new(uri)
-            req['Authorization'] = "Bearer #{bearer_token}" if bearer_token
-            response = http.request(req)
-            if response.is_a?(Net::HTTPSuccess)
-              data = JSON.parse(response.body, symbolize_names: true)
-              {
-                success: true,
-                skill_name: data[:name] || skill_id,
-                format: data[:format] || 'markdown',
-                content: data[:content],
-                content_hash: data[:content_hash],
-                size_bytes: data[:content]&.bytesize || 0,
-                depositor_id: data[:depositor_id],
-                trust_notice: data[:trust_notice]
-              }
-            else
-              { success: false, error: "HTTP #{response.code}: #{response.body}" }
-            end
-          rescue StandardError => e
-            { success: false, error: e.message }
-          end
-
-          def get_skill_from_relay(url, skill_id)
-            uri = URI.parse("#{url}/place/v1/skills/content/#{URI.encode_www_form_component(skill_id)}")
-            response = Net::HTTP.get_response(uri)
-            if response.is_a?(Net::HTTPSuccess)
-              data = JSON.parse(response.body, symbolize_names: true)
-              { success: true, skill_name: data[:name] || skill_id, format: data[:format] || 'markdown', content: data[:content], content_hash: data[:content_hash], size_bytes: data[:content]&.bytesize || 0 }
-            else
-              { success: false, error: "HTTP #{response.code}" }
-            end
-          rescue StandardError => e
-            { success: false, error: e.message }
-          end
-
-          def get_skill_direct(endpoint, skill_id, bearer_token: nil)
-            uri = URI.parse("#{endpoint}/meeting/v1/skill_content")
-            http = Net::HTTP.new(uri.host, uri.port); http.use_ssl = (uri.scheme == 'https')
-            http.open_timeout = 5; http.read_timeout = 10
-            req = Net::HTTP::Post.new(uri.path)
-            req['Content-Type'] = 'application/json'
-            req['Authorization'] = "Bearer #{bearer_token}" if bearer_token
-            req.body = JSON.generate({ skill_id: skill_id })
-            response = http.request(req)
-            if response.is_a?(Net::HTTPSuccess)
-              data = JSON.parse(response.body, symbolize_names: true)
-              payload = data.dig(:message, :payload) || data[:payload] || data
-              { success: true, skill_name: payload[:skill_name] || skill_id, format: payload[:format] || 'markdown', content: payload[:content], content_hash: payload[:content_hash], size_bytes: payload[:content]&.bytesize || 0 }
-            else
-              { success: false, error: response.body }
-            end
-          rescue StandardError => e
-            { success: false, error: e.message }
-          end
         end
       end
     end

data/templates/skillsets/mmp/tools/meeting_browse.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'net/http'
-require 'uri'
 require 'json'
 
 module KairosMcp
@@ -43,30 +41,21 @@ module KairosMcp
           end
 
           def call(arguments)
-            config = ::MMP.load_config
-            unless config['enabled']
-              return text_content(JSON.pretty_generate({ error: 'Meeting Protocol is disabled' }))
-            end
-
-            connection = load_connection_state
-            unless connection
-              return text_content(JSON.pretty_generate({ error: 'Not connected', hint: 'Use meeting_connect first' }))
-            end
-
-            url = connection['url'] || connection[:url]
-            token = connection['session_token'] || connection[:session_token]
+            client = build_place_client
+            return client if client.is_a?(Array)
 
             begin
               page_size = [[arguments['page_size'] || 20, 50].min, 1].max
-              params = { 'limit' => page_size.to_s }
-              params['tags'] = arguments['tags'].join(',') if arguments['tags'] && !arguments['tags'].empty?
-              params['search'] = arguments['search'] if arguments['search']
-              params['type'] = arguments['type'] if arguments['type']
 
-              result = browse_place(url, token, params)
+              result = client.browse(
+                type: arguments['type'],
+                search: arguments['search'],
+                tags: arguments['tags'],
+                limit: page_size
+              )
 
-              unless result
-                return text_content(JSON.pretty_generate({ error: 'Failed to browse Meeting Place' }))
+              if result[:error]
+                return text_content(JSON.pretty_generate({ error: 'Failed to browse Meeting Place', message: result[:error] }))
               end
 
               entries = result[:entries] || []
@@ -79,7 +68,6 @@ module KairosMcp
                 hint: entries.empty? ? 'No skills found. Try different filters or wait for agents to deposit skills.' : 'Use meeting_acquire_skill(skill_id: "...") to acquire a skill.'
               }
 
-              # Pass through place-level trust info (factual metadata only)
               output[:place_trust] = result[:place_trust] if result[:place_trust]
 
               # Check for pending attestation nudge
@@ -100,25 +88,31 @@ module KairosMcp
 
           private
 
+          def build_place_client
+            config = ::MMP.load_config
+            unless config['enabled']
+              return text_content(JSON.pretty_generate({ error: 'Meeting Protocol is disabled' }))
+            end
+            connection = load_connection_state
+            unless connection
+              return text_content(JSON.pretty_generate({ error: 'Not connected', hint: 'Use meeting_connect first' }))
+            end
+            url = connection['url'] || connection[:url]
+            token = connection['session_token'] || connection[:session_token]
+            agent_id = connection['agent_id'] || connection[:agent_id]
+            identity = ::MMP::Identity.new(config: config)
+            ::MMP::PlaceClient.reconnect(
+              place_url: url, identity: identity,
+              session_token: token, agent_id: agent_id
+            )
+          end
+
           def load_connection_state
             f = File.join(KairosMcp.storage_dir, 'meeting_connection.json')
             File.exist?(f) ? JSON.parse(File.read(f)) : nil
           rescue StandardError; nil
           end
 
-          def browse_place(url, token, params)
-            query = URI.encode_www_form(params)
-            uri = URI.parse("#{url}/place/v1/board/browse?#{query}")
-            http = Net::HTTP.new(uri.host, uri.port); http.use_ssl = (uri.scheme == 'https')
-            http.open_timeout = 5; http.read_timeout = 10
-            req = Net::HTTP::Get.new(uri)
-            req['Authorization'] = "Bearer #{token}" if token
-            response = http.request(req)
-            response.is_a?(Net::HTTPSuccess) ? JSON.parse(response.body, symbolize_names: true) : nil
-          rescue StandardError
-            nil
-          end
-
           def format_entry(entry)
             base = {
               type: entry[:type] || entry[:format],

data/templates/skillsets/mmp/tools/meeting_deposit.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'net/http'
-require 'uri'
 require 'json'
 require 'yaml'
 require 'digest'
@@ -42,20 +40,11 @@ module KairosMcp
           end
 
           def call(arguments)
-            config = ::MMP.load_config
-            unless config['enabled']
-              return text_content(JSON.pretty_generate({ error: 'Meeting Protocol is disabled' }))
-            end
-
-            connection = load_connection_state
-            unless connection
-              return text_content(JSON.pretty_generate({ error: 'Not connected', hint: 'Use meeting_connect first' }))
-            end
-
-            url = connection['url'] || connection[:url]
-            token = connection['session_token'] || connection[:session_token]
+            client = build_place_client(timeout: 15)
+            return client if client.is_a?(Array)
 
             begin
+              config = ::MMP.load_config
               identity = ::MMP::Identity.new(config: config)
               crypto = identity.crypto
 
@@ -79,7 +68,7 @@ module KairosMcp
                 content_hash = Digest::SHA256.hexdigest(content)
                 signature = crypto.has_keypair? ? crypto.sign(content) : nil
 
-                result = deposit_to_place(url, token, {
+                result = client.deposit({
                   skill_id: skill[:name],
                   name: skill[:name],
                   description: skill[:description],
@@ -117,6 +106,25 @@ module KairosMcp
 
           private
 
+          def build_place_client(timeout: 10)
+            config = ::MMP.load_config
+            unless config['enabled']
+              return text_content(JSON.pretty_generate({ error: 'Meeting Protocol is disabled' }))
+            end
+            connection = load_connection_state
+            unless connection
+              return text_content(JSON.pretty_generate({ error: 'Not connected', hint: 'Use meeting_connect first' }))
+            end
+            url = connection['url'] || connection[:url]
+            token = connection['session_token'] || connection[:session_token]
+            agent_id = connection['agent_id'] || connection[:agent_id]
+            identity = ::MMP::Identity.new(config: config)
+            ::MMP::PlaceClient.reconnect(
+              place_url: url, identity: identity,
+              session_token: token, agent_id: agent_id, timeout: timeout
+            )
+          end
+
           def load_connection_state
             f = File.join(KairosMcp.storage_dir, 'meeting_connection.json')
             File.exist?(f) ? JSON.parse(File.read(f)) : nil
@@ -170,20 +178,6 @@ module KairosMcp
           rescue StandardError
             0
           end
-
-          def deposit_to_place(url, token, skill)
-            uri = URI.parse("#{url}/place/v1/deposit")
-            http = Net::HTTP.new(uri.host, uri.port); http.use_ssl = (uri.scheme == 'https')
-            http.open_timeout = 5; http.read_timeout = 15
-            req = Net::HTTP::Post.new(uri.path)
-            req['Content-Type'] = 'application/json'
-            req['Authorization'] = "Bearer #{token}" if token
-            req.body = JSON.generate(skill)
-            response = http.request(req)
-            JSON.parse(response.body, symbolize_names: true)
-          rescue StandardError => e
-            { error: e.message }
-          end
         end
       end
     end

data/templates/skillsets/mmp/tools/meeting_federate.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'net/http'
-require 'uri'
 require 'json'
 require 'digest'
 
@@ -64,13 +62,29 @@ module KairosMcp
             filter_tags = arguments['tags']
 
             begin
-              # Resolve Place IDs for provenance chain (prefer place_id, fallback to URL)
-              source_place_id = resolve_place_id(source_url) || source_url
+              source_client = build_client_for(url: source_url, token: source_token)
+              target_client = build_client_for(url: target_url, token: target_token, timeout: 15)
+
+              # Resolve Place ID for provenance chain
+              info_result = source_client.place_info
+              source_place_id = info_result[:place_id] || source_url
 
               # Step 1: Browse source Place for deposited skills
-              source_skills = browse_deposited_skills(source_url, source_token, tags: filter_tags)
-              if source_skills.nil?
-                return text_content(JSON.pretty_generate({ error: 'Failed to browse source Place' }))
+              source_result = source_client.browse(type: 'deposited_skill', tags: filter_tags, limit: 50)
+              if source_result[:error]
+                return text_content(JSON.pretty_generate({ error: 'Failed to browse source Place', message: source_result[:error] }))
+              end
+
+              source_skills = (source_result[:entries] || []).map do |e|
+                {
+                  skill_id: e[:skill_id],
+                  name: e[:name],
+                  description: e[:description],
+                  tags: e[:tags],
+                  owner_agent_id: e[:agent_id],
+                  deposited_at: e[:deposited_at],
+                  trust_metadata: e[:trust_metadata]
+                }
               end
 
               # Filter by skill_ids if specified
@@ -91,11 +105,11 @@ module KairosMcp
 
               source_skills.each do |skill_meta|
                 # GET full content from source
-                content_result = get_skill_content(
-                  source_url, source_token,
-                  skill_meta[:skill_id],
-                  owner_agent_id: skill_meta[:owner_agent_id]
+                raw = source_client.get_skill_content(
+                  skill_id: skill_meta[:skill_id],
+                  owner: skill_meta[:owner_agent_id]
                 )
+                content_result = adapt_place_skill_content(raw, skill_meta[:skill_id])
 
                 unless content_result[:success]
                   failed << { skill_id: skill_meta[:skill_id], error: content_result[:error] }
@@ -115,7 +129,7 @@ module KairosMcp
                 signature = crypto.has_keypair? ? crypto.sign(content) : nil
 
                 # POST to target Place with provenance
-                deposit_result = deposit_to_target(target_url, target_token, {
+                deposit_result = target_client.deposit({
                   skill_id: skill_meta[:skill_id],
                   name: content_result[:name] || skill_meta[:name],
                   description: skill_meta[:description],
@@ -163,83 +177,37 @@ module KairosMcp
 
           private
 
-          # Browse source Place for deposited_skill entries only
-          def browse_deposited_skills(url, token, tags: nil)
-            params = { 'type' => 'deposited_skill', 'limit' => '50' }
-            params['tags'] = tags.join(',') if tags && !tags.empty?
-
-            query = URI.encode_www_form(params)
-            uri = URI.parse("#{url}/place/v1/board/browse?#{query}")
-            http = Net::HTTP.new(uri.host, uri.port); http.use_ssl = (uri.scheme == 'https')
-            http.open_timeout = 5; http.read_timeout = 10
-            req = Net::HTTP::Get.new(uri)
-            req['Authorization'] = "Bearer #{token}"
-            response = http.request(req)
-            return nil unless response.is_a?(Net::HTTPSuccess)
-
-            data = JSON.parse(response.body, symbolize_names: true)
-            (data[:entries] || []).map do |e|
-              {
-                skill_id: e[:skill_id],
-                name: e[:name],
-                description: e[:description],
-                tags: e[:tags],
-                owner_agent_id: e[:agent_id],
-                deposited_at: e[:deposited_at],
-                trust_metadata: e[:trust_metadata]
-              }
-            end
-          rescue StandardError
-            nil
+          # Build PlaceClient for explicit URL/token (federate uses explicit args, not connection state)
+          def build_client_for(url:, token:, timeout: 10)
+            identity = ::MMP::Identity.new(config: ::MMP.load_config)
+            ::MMP::PlaceClient.reconnect(
+              place_url: url, identity: identity,
+              session_token: token, timeout: timeout
+            )
           end
 
-          # GET skill content from source Place
-          def get_skill_content(url, token, skill_id, owner_agent_id: nil)
-            path = "/place/v1/skill_content/#{URI.encode_www_form_component(skill_id)}"
-            path += "?owner=#{URI.encode_www_form_component(owner_agent_id)}" if owner_agent_id
-            uri = URI.parse("#{url}#{path}")
-            http = Net::HTTP.new(uri.host, uri.port); http.use_ssl = (uri.scheme == 'https')
-            http.open_timeout = 5; http.read_timeout = 10
-            req = Net::HTTP::Get.new(uri)
-            req['Authorization'] = "Bearer #{token}"
-            response = http.request(req)
-            if response.is_a?(Net::HTTPSuccess)
-              data = JSON.parse(response.body, symbolize_names: true)
+          # Adapter A1: Place deposit skill content
+          def adapt_place_skill_content(raw, skill_id)
+            if raw[:error]
+              { success: false, error: raw[:error] }
+            else
               {
                 success: true,
-                name: data[:name],
-                content: data[:content],
-                content_hash: data[:content_hash],
-                format: data[:format],
-                depositor_id: data[:depositor_id]
+                name: raw[:name] || skill_id,
+                skill_name: raw[:name] || skill_id,
+                format: raw[:format] || 'markdown',
+                content: raw[:content],
+                content_hash: raw[:content_hash],
+                size_bytes: raw[:content]&.bytesize || 0,
+                depositor_id: raw[:depositor_id],
+                trust_notice: raw[:trust_notice]
               }
-            else
-              { success: false, error: "HTTP #{response.code}" }
             end
-          rescue StandardError => e
-            { success: false, error: e.message }
-          end
-
-          # Resolve Place's instance ID from /place/v1/info (unauthenticated).
-          # Returns nil on failure (caller should fallback to URL).
-          def resolve_place_id(url)
-            uri = URI.parse("#{url}/place/v1/info")
-            http = Net::HTTP.new(uri.host, uri.port); http.use_ssl = (uri.scheme == 'https')
-            http.open_timeout = 3; http.read_timeout = 5
-            req = Net::HTTP::Get.new(uri)
-            response = http.request(req)
-            return nil unless response.is_a?(Net::HTTPSuccess)
-            data = JSON.parse(response.body, symbolize_names: true)
-            data[:place_id]
-          rescue StandardError
-            nil
           end
 
           # Build provenance for the federated deposit.
-          # source_place_id: resolved Place instance ID (or URL as fallback).
           def build_federation_provenance(source_provenance, source_place_id, content_result, source_deposited_at)
             if source_provenance[:hop_count].to_i > 0
-              # Already federated: increment hop, append source to via
               {
                 origin_place_id: source_provenance[:origin_place_id],
                 origin_agent_id: source_provenance[:origin_agent_id] || content_result[:depositor_id],
@@ -248,7 +216,6 @@ module KairosMcp
                 deposited_at_origin: source_provenance[:deposited_at_origin]
               }
             else
-              # First federation: source Place is the origin
               {
                 origin_place_id: source_place_id,
                 origin_agent_id: content_result[:depositor_id],
@@ -258,21 +225,6 @@ module KairosMcp
               }
             end
           end
-
-          # POST skill to target Place with provenance
-          def deposit_to_target(url, token, skill)
-            uri = URI.parse("#{url}/place/v1/deposit")
-            http = Net::HTTP.new(uri.host, uri.port); http.use_ssl = (uri.scheme == 'https')
-            http.open_timeout = 5; http.read_timeout = 15
-            req = Net::HTTP::Post.new(uri.path)
-            req['Content-Type'] = 'application/json'
-            req['Authorization'] = "Bearer #{token}"
-            req.body = JSON.generate(skill)
-            response = http.request(req)
-            JSON.parse(response.body, symbolize_names: true)
-          rescue StandardError => e
-            { error: e.message }
-          end
         end
       end
     end

data/templates/skillsets/mmp/tools/meeting_get_skill_details.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'net/http'
-require 'uri'
 require 'json'
 
 module KairosMcp
@@ -34,8 +32,7 @@ module KairosMcp
               type: 'object',
               properties: {
                 peer_id: { type: 'string', description: 'ID of the peer agent' },
-                skill_id: { type: 'string', description: 'ID of the skill' },
-                include_preview: { type: 'boolean', description: 'Include content preview (default: false)' }
+                skill_id: { type: 'string', description: 'ID of the skill' }
               },
               required: %w[peer_id skill_id]
             }
@@ -44,12 +41,6 @@ module KairosMcp
           def call(arguments)
             peer_id = arguments['peer_id']
             skill_id = arguments['skill_id']
-            include_preview = arguments['include_preview'] || false
-
-            config = ::MMP.load_config
-            unless config['enabled']
-              return text_content(JSON.pretty_generate({ error: 'Meeting Protocol is disabled' }))
-            end
 
             connection = load_connection_state
             unless connection
@@ -62,31 +53,36 @@ module KairosMcp
             end
 
             begin
-              relay_mode = connection['relay_mode'] || connection[:relay_mode]
-              url = connection['url'] || connection[:url]
+              # Target: peer endpoint if available, otherwise Place URL
               endpoint = peer['endpoint'] || peer[:endpoint]
-
-              # In relay mode, use the peer's endpoint if available,
-              # otherwise fall back to the connection URL (Meeting Place itself)
+              url = connection['url'] || connection[:url]
               target = endpoint || url
-              token = connection['session_token'] || connection[:session_token]
-              details = get_details_direct(target, skill_id, bearer_token: token)
 
-              unless details
+              client = build_meeting_client(url_override: target, timeout: 5)
+              return client if client.is_a?(Array)
+
+              raw = client.get_skill_details(skill_id: skill_id)
+              details = adapt_skill_details(raw)
+
+              if details.nil?
                 return text_content(JSON.pretty_generate({ error: "Skill not found: #{skill_id}" }))
               end
 
+              if details[:error]
+                return text_content(JSON.pretty_generate({ error: details[:error], message: details[:message] }))
+              end
+
               result = {
                 peer_id: peer_id,
                 peer_name: peer['name'] || peer[:name],
                 skill: {
                   id: skill_id,
-                  name: details['name'] || details[:name],
-                  description: details['description'] || details[:description],
-                  version: details['version'] || details[:version] || '1.0.0',
-                  format: details['format'] || details[:format] || 'markdown',
-                  tags: details['tags'] || details[:tags] || [],
-                  size_bytes: details['size_bytes'] || details[:size_bytes]
+                  name: details[:name],
+                  description: details[:description],
+                  version: details[:version],
+                  format: details[:format],
+                  tags: details[:tags],
+                  size_bytes: details[:size_bytes]
                 },
                 hint: "To acquire: meeting_acquire_skill(peer_id: \"#{peer_id}\", skill_id: \"#{skill_id}\")"
               }
@@ -119,22 +115,52 @@ module KairosMcp
             (connection['peers'] || connection[:peers] || []).find { |p| (p['agent_id'] || p[:agent_id]) == peer_id }
           end
 
-          def get_details_relay(url, skill_id)
-            uri = URI.parse("#{url}/place/v1/skills/metadata/#{URI.encode_www_form_component(skill_id)}")
-            response = Net::HTTP.get_response(uri)
-            response.is_a?(Net::HTTPSuccess) ? JSON.parse(response.body, symbolize_names: true) : nil
-          rescue StandardError; nil
+          # Build PlaceClient with meeting_session_token for /meeting/v1/* endpoints
+          def build_meeting_client(url_override: nil, timeout: 10)
+            config = ::MMP.load_config
+            unless config['enabled']
+              return text_content(JSON.pretty_generate({ error: 'Meeting Protocol is disabled' }))
+            end
+            connection = load_connection_state
+            unless connection
+              return text_content(JSON.pretty_generate({ error: 'Not connected', hint: 'Use meeting_connect first' }))
+            end
+            url = url_override || connection['url'] || connection[:url]
+            token = connection['meeting_session_token'] || connection[:meeting_session_token]
+            unless token
+              return text_content(JSON.pretty_generate({
+                error: 'No meeting session token',
+                hint: 'meeting_connect may have failed the /meeting/v1/introduce handshake. Reconnect.'
+              }))
+            end
+            identity = ::MMP::Identity.new(config: config)
+            ::MMP::PlaceClient.reconnect(
+              place_url: url, identity: identity,
+              session_token: token, timeout: timeout
+            )
           end
 
-          def get_details_direct(endpoint, skill_id, bearer_token: nil)
-            uri = URI.parse("#{endpoint}/meeting/v1/skill_details?skill_id=#{URI.encode_www_form_component(skill_id)}")
-            http = Net::HTTP.new(uri.host, uri.port); http.use_ssl = (uri.scheme == 'https')
-            http.open_timeout = 3; http.read_timeout = 5
-            req = Net::HTTP::Get.new(uri)
-            req['Authorization'] = "Bearer #{bearer_token}" if bearer_token
-            response = http.request(req)
-            response.is_a?(Net::HTTPSuccess) ? JSON.parse(response.body, symbolize_names: true) : nil
-          rescue StandardError; nil
+          # Adapter A3: skill_details response normalization
+          # Distinguishes "not found" from auth/network errors (R3-1 fix)
+          def adapt_skill_details(raw)
+            if raw[:error]
+              # Distinguish not_found from other errors
+              if raw[:error].to_s.include?('not_found') || raw[:error].to_s.include?('404')
+                nil
+              else
+                { error: raw[:error], message: raw[:message] }
+              end
+            else
+              meta = raw[:metadata] || raw
+              {
+                name: meta[:name],
+                description: meta[:description] || meta[:summary],
+                version: meta[:version] || '1.0',
+                format: meta[:format] || 'markdown',
+                tags: meta[:tags] || [],
+                size_bytes: meta[:size_bytes]
+              }
+            end
           end
         end
       end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kairos-chain
 version: !ruby/object:Gem::Version
-  version: 3.14.1
+  version: 3.15.0
 platform: ruby
 authors:
 - Masaomi Hatakeyama
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-04-12 00:00:00.000000000 Z
+date: 2026-04-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest