sveda-ruby-sdk 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6eeb554b62506ea6bfb1add0c5e29ebba46e8ae3bf87de7015b00bfab146a419
-  data.tar.gz: 8cb7998b373799ae77f3548d5759ceb023c3dea9f8f525395ec117423c747fe5
+  metadata.gz: '00651658d2c76433a154d2242b34dee5ab7bce230eb736e40f4db82bee57e361'
+  data.tar.gz: 55290570fc7c2d55a1c7c5fbe2ec6a89121197806052c72074d48f17737efb09
 SHA512:
-  metadata.gz: a63034bd24c1afa1a65a6fd980f50cad5810ef7fc0a33bcda610430c6d414de58abd73dc8ac4cbeb20d72871f12950c86d8d5a19c89b141625b986b73962342e
-  data.tar.gz: 32ea314d6672ff68914a4d0fe148c4167dbcab3cf8bd3ece4f24329260795dbcb82fc18a03a99cbe6ecdb63c0a9c62822ac14897f7f626b9da23af8eada4c6ef
+  metadata.gz: d7981b49a07f64c70bfeb78ff82f4b3e6deb6b37f581c55c737f4ed70756a0bab2e47a0cb5eb19eb213aed848535cf3ba8b7ebc622775ea2ca84b6dac7443ea6
+  data.tar.gz: 19da124e14de0579233719d35922362b38f437de533606eb1f00980c5dfbaa1a73ffb18d4013a94d4e1a342040370dbb4e38e36b68d7bc8bcb6167a1b2882cd8

data/README.md

@@ -45,7 +45,8 @@ server = Sveda::Host::Server.new(
   server_name: "My App",
   instructions: "Tools for the current user."
 )
-server.resolve_tools_using { [SearchPostsTool.new] }
+server.resolve_tools_using { |user| [SearchPostsTool.new] }
+server.policy_using { |_user| "agent" }
 
 # Rails routes.rb
 post "/sveda/session", to: "sveda_sessions#create"

data/lib/sveda/client.rb

@@ -23,7 +23,7 @@ module Sveda
       Histories.new(@transport)
     end
 
-    def self.start_host_session(base_url:, host_api_key:, visitor_id:, host_mcp_url: nil, host_mcp_token: nil, **client_kwargs)
+    def self.start_host_session(base_url:, host_api_key:, visitor_id:, host_mcp_url: nil, host_mcp_token: nil, policy: nil, grants: nil, **client_kwargs)
       origin = base_url.to_s.strip.sub(%r{/\z}, "")
       key = host_api_key.to_s.strip
       if origin.empty? || key.empty?
@@ -34,7 +34,9 @@ module Sveda
       token = client.embed.create_token(
         visitor_id: visitor_id,
         host_mcp_url: host_mcp_url,
-        host_mcp_token: host_mcp_token
+        host_mcp_token: host_mcp_token,
+        policy: policy,
+        grants: grants
       )
       if token.token.empty?
         raise Error, "Sidecar returned an empty embed token."

data/lib/sveda/embed.rb

@@ -6,13 +6,17 @@ module Sveda
       @transport = transport
     end
 
-    def create_token(visitor_id: nil, host_mcp_url: nil, host_mcp_token: nil)
+    def create_token(visitor_id: nil, host_mcp_url: nil, host_mcp_token: nil, policy: nil, grants: nil)
       payload = {}
       payload["visitor_id"] = visitor_id if visitor_id.to_s != ""
       if host_mcp_url.to_s != "" && host_mcp_token.to_s != ""
         payload["host_mcp_url"] = host_mcp_url
         payload["host_mcp_token"] = host_mcp_token
       end
+      if !policy.nil? && policy.to_s.strip != ""
+        payload["policy"] = policy.to_s.strip
+      end
+      payload["grants"] = grants if grants.is_a?(Hash)
 
       EmbedToken.from_payload(@transport.request_json("POST", "/sveda/embed/token", payload))
     end

data/lib/sveda/host/mcp_handler.rb

@@ -15,9 +15,10 @@ module Sveda
         return method_not_allowed unless request.post?
 
         token = bearer_token(request)
-        return unauthorized unless @server.authenticate_token(token)
-        return forbidden unless @server.authorized?
-        @server.run_after_authenticate
+        user = @server.authenticate_token(token)
+        return unauthorized if user.nil?
+        return forbidden unless @server.authorized?(user)
+        @server.run_after_authenticate(user)
 
         payload = JSON.parse(request.body.read)
         return bad_request unless payload["jsonrpc"] == "2.0"
@@ -32,9 +33,9 @@ module Sveda
         when "initialize"
           json_rpc(id, initialize_result)
         when "tools/list"
-          json_rpc(id, { tools: list_tools })
+          json_rpc(id, { tools: list_tools(user) })
         when "tools/call"
-          json_rpc(id, call_tool(params))
+          json_rpc(id, call_tool(params, user))
         else
           [202, {}, []]
         end
@@ -58,8 +59,8 @@ module Sveda
         result
       end
 
-      def list_tools
-        @server.tools.map do |tool|
+      def list_tools(user)
+        @server.tools(user).map do |tool|
           {
             name: tool.name,
             title: tool.name,
@@ -73,10 +74,10 @@ module Sveda
         end
       end
 
-      def call_tool(params)
+      def call_tool(params, user)
         name = params["name"].to_s
         arguments = params["arguments"].is_a?(Hash) ? params["arguments"] : {}
-        tool = @server.tools.find { |candidate| candidate.name == name }
+        tool = @server.tools(user).find { |candidate| candidate.name == name }
         return tool_error("unknown tool: #{name}") unless tool
 
         result = tool.handle(arguments)

data/lib/sveda/host/server.rb

@@ -23,17 +23,23 @@ module Sveda
         }
         @token_store = MemoryTokenStore.new(ttl_seconds: token_ttl_seconds)
         @resolve_tools = nil
+        @policy_using = nil
         @tools = []
-        @mint_token = -> { @token_store.mint }
-        @authenticate = ->(token) { @token_store.valid?(token) }
+        @mint_token = ->(user = nil) { @token_store.mint(user_id: user_id_for(user)) }
+        @authenticate = ->(token) { @token_store.lookup(token) }
         @authorize = nil
         @after_authenticate = nil
+        @current_user = nil
       end
 
       def resolve_tools_using(&block)
         @resolve_tools = block
       end
 
+      def policy_using(&block)
+        @policy_using = block
+      end
+
       def register_tool(tool)
         @tools << tool
       end
@@ -64,35 +70,60 @@ module Sveda
         @config[:mcp_path]
       end
 
-      def tools
-        @resolve_tools ? Array(@resolve_tools.call) : @tools
+      def tools(user = nil)
+        if @resolve_tools
+          return Array(invoke_resolve_tools(user))
+        end
+
+        @tools
+      end
+
+      def policy_for(user)
+        return nil unless @policy_using
+
+        value = @policy_using.call(user)
+        return nil if value.nil?
+
+        policy = value.to_s.strip
+        policy.empty? ? nil : policy
       end
 
       def authenticate_token(token)
-        @authenticate.call(token)
+        result = @authenticate.call(token)
+        return nil if result.nil? || result == false
+
+        if result == true
+          { "id" => "anonymous" }
+        elsif result.is_a?(Hash)
+          result
+        else
+          { "id" => result.to_s }
+        end
       end
 
-      def authorized?
+      def authorized?(user = nil)
         return true unless @authorize
 
-        @authorize.call != false
+        @authorize.call(user) != false
       end
 
-      def run_after_authenticate
-        @after_authenticate&.call
+      def run_after_authenticate(user = nil)
+        @after_authenticate&.call(user)
       end
 
-      def start_session(visitor_id:, mcp_url: nil)
+      def start_session(visitor_id:, mcp_url: nil, user: nil)
         raise ConfigurationError, "Задайте SVEDA_CLIENT_BASE_URL и SVEDA_CLIENT_HOST_API_KEY" unless configured?
 
+        session_user = user.nil? ? visitor_id : user
         mcp = (mcp_url || self.mcp_url).to_s.strip.sub(%r{/\z}, "")
-        mcp_token = @mint_token.call
+        mcp_token = @mint_token.arity.zero? ? @mint_token.call : @mint_token.call(session_user)
         Sveda::Client.start_host_session(
           base_url: @config[:base_url],
           host_api_key: @config[:host_api_key],
           visitor_id: visitor_id,
           host_mcp_url: mcp.empty? ? nil : mcp,
           host_mcp_token: mcp_token,
+          policy: policy_for(session_user),
           **@client_kwargs
         )
       end
@@ -103,6 +134,24 @@ module Sveda
 
       private
 
+      def invoke_resolve_tools(user)
+        if @resolve_tools.arity.zero?
+          @resolve_tools.call
+        else
+          @resolve_tools.call(user)
+        end
+      end
+
+      def user_id_for(user)
+        return "anonymous" if user.nil?
+
+        if user.is_a?(Hash)
+          (user[:id] || user["id"] || "anonymous").to_s
+        else
+          user.to_s
+        end
+      end
+
       def normalize_path(path)
         value = path.to_s.strip
         value = "/mcp/sveda" if value.empty?

data/lib/sveda/host/token_store.rb

@@ -11,23 +11,29 @@ module Sveda
         @mutex = Mutex.new
       end
 
-      def mint
+      def mint(user_id: "anonymous")
         token = SecureRandom.hex(32)
         expires_at = Time.now + @ttl_seconds
         @mutex.synchronize do
           prune_locked
-          @tokens[token] = expires_at
+          @tokens[token] = { expires_at: expires_at, user_id: user_id.to_s }
         end
         token
       end
 
       def valid?(token)
-        return false if token.to_s.empty?
+        !lookup(token).nil?
+      end
+
+      def lookup(token)
+        return nil if token.to_s.empty?
 
         @mutex.synchronize do
           prune_locked
-          expires_at = @tokens[token.to_s]
-          expires_at && Time.now < expires_at
+          record = @tokens[token.to_s]
+          return nil unless record && Time.now < record[:expires_at]
+
+          { "id" => record[:user_id] }
         end
       end
 
@@ -35,7 +41,7 @@ module Sveda
 
       def prune_locked
         now = Time.now
-        @tokens.delete_if { |_token, expires_at| expires_at <= now }
+        @tokens.delete_if { |_token, record| record[:expires_at] <= now }
       end
     end
   end

data/lib/sveda/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sveda-ruby-sdk
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Neresson
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-09-20 00:00:00.000000000 Z
+date: 2026-09-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack