insika 0.0.1 → 0.1.0

data/lib/insika/server/a2a/http.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Insika
+  module Server
+    module A2A
+      # Production HTTP adapter: implements the duck-type
+      # `post_json(url, body) -> Hash` over async-http (runs on the turn's reactor).
+      # BOUNDARY — the lib require lives here, never in lib/insika.rb/wiring-load.
+      # The Client (the logic) is tested with a fake; this adapter, with a light test.
+      class Http
+        HEADERS = [["content-type", "application/json"], ["accept", "application/json"]].freeze
+
+        def initialize(internet: nil)
+          @internet = internet # lazy: Async::HTTP::Internet.new
+        end
+
+        # POST JSON -> Hash (parsed JSON-RPC, string keys).
+        def post_json(url, body)
+          response = internet.post(url, HEADERS, JSON.generate(body))
+          JSON.parse(response.read.to_s)
+        end
+
+        def close
+          @internet&.close
+        rescue StandardError
+          nil # best-effort
+        end
+
+        private
+
+        def internet
+          @internet ||= begin
+            require "async/http/internet"
+            Async::HTTP::Internet.new
+          end
+        end
+      end
+    end
+  end
+end

data/lib/insika/server/a2a/message.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Insika
+  module Server
+    module A2A
+      # Message parts translation: TextPart only in this slice.
+      # Tolerates `kind` (A2A ~v0.2+) and `type` (older spec) at the boundary.
+      module Message
+        # A2A Message (Hash) -> String (concatenates the TextParts). "" if none.
+        def self.text_from(a2a_message)
+          parts = a2a_message.is_a?(Hash) ? Array(a2a_message["parts"] || a2a_message[:parts]) : []
+          parts.filter_map do |part|
+            next unless part.is_a?(Hash)
+
+            kind = part["kind"] || part["type"] || part[:kind] || part[:type]
+            (part["text"] || part[:text]).to_s if kind.to_s == "text"
+          end.join
+        end
+
+        # String -> A2A Message (role agent, 1 TextPart).
+        def self.agent_message(text)
+          { role: "agent", parts: [{ kind: "text", text: text.to_s }] }
+        end
+      end
+    end
+  end
+end

data/lib/insika/server/a2a/protocol.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require_relative "errors"
+
+module Insika
+  module Server
+    module A2A
+      # JSON-RPC 2.0 envelope. PURE — receives the already
+      # deserialized Hash (raw JSON parsing belongs to Server::App). NEVER raises.
+      module Protocol
+        VERSION = "2.0"
+
+        # -> [:ok, { id:, method:, params: }] | [:error, { id:, code:, message: }]
+        def self.parse(body)
+          return err(nil, Errors::INVALID_REQUEST, "request must be a JSON-RPC object") unless body.is_a?(Hash)
+
+          id = body["id"] # missing -> nil (we always respond; no notifications in this slice)
+          return err(id, Errors::INVALID_REQUEST, "jsonrpc must be '2.0'") unless body["jsonrpc"] == VERSION
+
+          method = body["method"]
+          return err(id, Errors::INVALID_REQUEST, "method missing") unless method.is_a?(String) && !method.empty?
+
+          [:ok, { id: id, method: method, params: body["params"] || {} }]
+        end
+
+        # { jsonrpc:, id:, result: }
+        def self.result(id, result)
+          { jsonrpc: VERSION, id: id, result: result }
+        end
+
+        # { jsonrpc:, id:, error: { code:, message:, data? } }
+        def self.error(id, code, message, data: nil)
+          err = { code: code, message: message }
+          err[:data] = data unless data.nil?
+          { jsonrpc: VERSION, id: id, error: err }
+        end
+
+        def self.err(id, code, message)
+          [:error, { id: id, code: code, message: message }]
+        end
+        private_class_method :err
+      end
+    end
+  end
+end

data/lib/insika/server/a2a/remotes.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Insika
+  module Server
+    module A2A
+      # Remote A2A agents config. Parses "id=url,id2=url2".
+      module Remotes
+        Remote = Data.define(:id, :url, :description)
+
+        # -> [Remote]. Malformed entries (no '=', empty id/url) are ignored
+        # with a warn. env nil/"" -> [].
+        def self.parse(env_string, descriptions: {})
+          env_string.to_s.split(",").filter_map do |entry|
+            id, url = entry.split("=", 2).map { |s| s.to_s.strip }
+            if id.to_s.empty? || url.to_s.empty?
+              warn "[a2a] malformed remote ignored: #{entry.inspect} (use id=url)"
+              next
+            end
+            Remote.new(id: id, url: url, description: descriptions[id])
+          end
+        end
+      end
+    end
+  end
+end

data/lib/insika/server/a2a/task_projection.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative "message"
+
+module Insika
+  module Server
+    module A2A
+      # Task (core) -> A2A Task projection. PURE.
+      module TaskProjection
+        # State map. Unknown state -> "unknown".
+        STATE = {
+          queued: "submitted", running: "working", waiting: "input-required",
+          paused: "working", completed: "completed", failed: "failed", cancelled: "canceled"
+        }.freeze
+
+        # task (TaskStore::Task) + content/error (String|nil) + at (ISO8601) -> Hash A2A Task.
+        def self.call(task, at:, content: nil, error: nil)
+          state = STATE.fetch(task.status.to_sym, "unknown")
+          status = { state: state, timestamp: at }
+          msg = status_message(state, content, error)
+          status[:message] = msg if msg
+
+          {
+            id: task.id, contextId: task.session_id, kind: "task",
+            status: status, artifacts: [], history: []
+          }
+        end
+
+        # completed -> content; failed -> error; other states have no message.
+        def self.status_message(state, content, error)
+          case state
+          when "completed" then content && Message.agent_message(content)
+          when "failed"    then error && Message.agent_message(error)
+          end
+        end
+        private_class_method :status_message
+      end
+    end
+  end
+end

data/lib/insika/server/admin_auth.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "rack"
+require "rack/utils"
+
+module Insika
+  module Server
+    # Minimal operator auth. Fail-closed BY CONSTRUCTION: with no
+    # token configured, /admin does not exist to the world (503) — never open
+    # by omission. Pure module, testable without a Rack env.
+    module AdminAuth
+      module_function
+
+      # config_token: config[:admin_token] (the wiring reads ADMIN_TOKEN).
+      # header: raw Authorization value.
+      # -> :disabled | :unauthorized | :ok
+      def check(config_token, header)
+        return :disabled if config_token.nil? || config_token.empty?
+
+        provided = header.to_s[/\ABearer (.+)\z/, 1]
+        return :unauthorized if provided.nil?
+        # Constant-time comparison: the operator token doesn't leak via timing.
+        return :unauthorized unless Rack::Utils.secure_compare(config_token, provided)
+
+        :ok
+      end
+    end
+  end
+end