bundleup-sdk 0.5.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ab7e53fa4d67aa688569b213a6b9f090cce9b8e557203e598ef4ce946e4ac508
-  data.tar.gz: 5226846b47d962f8c616eb14e6c47ee8836bde8a63f610cfc155fda1eec879df
+  metadata.gz: 9265bf377a655ed9056e02bd22d1ec24fec68304e7ad4881c99013c42ca516f2
+  data.tar.gz: 4f9dac8314ce2d26640048984f7bef53e8921dfa9d4a7be5c5857412af5d3b00
 SHA512:
-  metadata.gz: 0a8085e498cfd804bbd5d7b93840997f0d719a4d040d4d0639f2d51621976217b1cfb1038db537e0ca46d917c0440a8ed6b7ab83b3e362c34d45c064dff7a1df
-  data.tar.gz: 823c5ebb016f7c2f31cdae1a838556f2ea7d62a25d0d6193aead188dfe045392cbf940892f258d24a2167fbc5f620816d03274154d07535031c66535c232909d
+  metadata.gz: 9e24b6ae2f52e09f5a2eb65e697b1080b4f8a36c5052097ea660b145fec36c7b85aef08ce85979d21023e65aa2788b4444071993e2f3ba3ea5b1f11bdbd2b48f
+  data.tar.gz: 71008902408646b7d4e171c186bc28337f0b67c7b36e218f01b2cf637402b06edf27cc2fa070dd036a35d9d428eecdad51f7935e1f2618e7dfdbd61b92b2949e

data/README.md

@@ -72,7 +72,7 @@ The BundleUp SDK is tested and supported on:
 - 🔌 **100+ Integrations** - Connect to Slack, GitHub, Jira, Linear, and many more
 - 🎯 **Unified API** - Consistent interface across all integrations via Unify API
 - 🔑 **Proxy API** - Direct access to underlying integration APIs
-- 🤖 **MCP** - Connect agents to a provider's own MCP server or to BundleUp's Unified MCP
+- 🤖 **MCP** - Hand a connection to any MCP client, or to OpenAI and Anthropic's hosted MCP
 - 🪶 **Lightweight** - Minimal dependencies
 - 🛡️ **Error Handling** - Comprehensive error messages and validation
 - 📚 **Well Documented** - Extensive documentation and examples
@@ -1340,47 +1340,14 @@ Reach a provider's own MCP server using a connection's credentials. BundleUp inj
 
 Supported for providers that run a first-party MCP server — see the [integrations page](https://www.bundleup.io/integrations). Others return an `mcp_not_supported` error.
 
-`post` and `delete` are transport only, like the Proxy API — responses come back untouched as `Faraday::Response` objects. `connect` layers a managed session on top when you would rather not drive the protocol yourself.
+BundleUp does not ship an MCP client. Hand `hosted` or `transport` to the one you already use, or send JSON-RPC yourself with `post` and `delete`, which return the response untouched as `Faraday::Response` objects, like the Proxy API.
 
-#### Creating an MCP Client
+#### Creating an MCP Instance
 
 ```ruby
 mcp = client.mcp('conn_123abc')
 ```
 
-#### Managed Sessions
-
-`connect` returns a client that handles the handshake, session ID and response decoding, and exposes what the provider offers.
-
-```ruby
-mcp = client.mcp('conn_123abc').connect
-
-tools = mcp.list_tools
-result = mcp.call_tool('create_issue', { title: 'Login broken' })
-
-mcp.close
-```
-
-Resources and prompts follow the same shape:
-
-```ruby
-resources = mcp.list_resources
-contents = mcp.read_resource('file:///readme.md')
-
-prompts = mcp.list_prompts
-messages = mcp.get_prompt('summarize', { id: '123' })
-```
-
-Anything else in the protocol:
-
-```ruby
-mcp.request('logging/setLevel', { level: 'debug' })
-```
-
-The handshake runs lazily on the first call and once per client, list methods follow `nextCursor` to the end, and `text/event-stream` responses are decoded for you. Results are hashes with string keys. Errors raise a `RuntimeError` with the provider's message, or BundleUp's with its code appended — `Missing or invalid connection ID (connection_invalid)`.
-
-Call `close` when you are done to end the session upstream.
-
 #### Model-Hosted MCP
 
 OpenAI and Anthropic can connect to an MCP server themselves, with no tool mapping or dispatch loop on your side. Both accept only a single credential and no custom headers, so `hosted` returns the server URL alongside the API key and connection joined into one bearer.
@@ -1403,7 +1370,7 @@ response = openai.responses.create(
 )
 ```
 
-Anthropic's connector takes the same pair as `url` and `authorization_token`. `client.unify('conn_123abc').mcp.hosted` returns them for Unified MCP.
+Anthropic's connector takes the same pair as `url` and `authorization_token`.
 
 `server_url` must be exactly the URL `hosted` returns — the proxy rebuilds the upstream URL from the provider's own base, so any path or query you append is ignored rather than rejected.
 
@@ -1506,45 +1473,29 @@ end
 
 Every JSON-RPC message counts toward the rate limit of 100 requests per 60 seconds, per connection — including the `initialize` handshake.
 
-#### Merging Several Connections
+#### Several Connections
 
-An agent often needs more than one provider for the same end user. There is no merge helper in the SDK — how tools are namespaced, filtered and recovered from differs enough per agent that it is better written where you can see it:
+An agent often needs more than one provider for the same end user. With model-hosted MCP there is nothing to merge — pass one `mcp` tool per connection and the model provider keeps them apart by `server_label`:
 
 ```ruby
-clients = {
-  'slack' => client.mcp(user.slack_connection).connect,
-  'linear' => client.mcp(user.linear_connection).connect,
-  'crm' => client.unify(user.hubspot_connection).mcp
-}
+connections = { 'slack' => user.slack_connection, 'linear' => user.linear_connection }
 
-# One namespaced list: slack__send_message, linear__create_issue, …
-tools = clients.flat_map do |label, mcp|
-  mcp.list_tools.map { |tool| tool.merge('name' => "#{label}__#{tool['name']}") }
-end
+tools = connections.map do |label, connection_id|
+  hosted = client.mcp(connection_id).hosted
 
-# Route a call back to the client that owns it
-call = lambda do |name, args|
-  label, tool_name = name.split('__', 2)
-  clients.fetch(label).call_tool(tool_name, args)
+  {
+    type: 'mcp',
+    server_label: label,
+    server_url: hosted[:url],
+    authorization: hosted[:token],
+    require_approval: 'never'
+  }
 end
 ```
 
-Anything that exposes `list_tools` and `call_tool(name, args)` fits the same shape, so an internal tool layer of your own can sit in that map alongside BundleUp connections.
-
-Two things worth handling that the sketch above skips. **Filter before you hand the list to a model** — three providers is easily sixty tools, and accuracy drops as that list grows, so select the ones the agent actually needs rather than passing everything. And decide what an unreachable provider should do: as written, one failing `list_tools` raises and fails the whole list, while a `rescue` per client lets the others through.
-
-#### Unified MCP
-
-BundleUp's normalized tools instead of the provider's, on the same protocol. Tools only — Unified MCP exposes no resources or prompts.
-
-```ruby
-mcp = client.unify('conn_123abc').mcp
-
-tools = mcp.list_tools
-result = mcp.call_tool('send_message', { text: 'Deploy finished' })
-```
+With an MCP client in your own backend, open one client per connection from its `transport`, prefix each tool name with a label (`slack__send_message`), and route calls back by that prefix. There is no merge helper in the SDK — how tools are namespaced, filtered and recovered from differs enough per agent that it is better written where you can see it.
 
-`unify.mcp` is memoized per Unify client, so the handshake runs once no matter how often you call it. The server itself is stateless and POST-only, so there is no session to close.
+**Filter before you hand tools to a model** — three providers is easily sixty tools, and accuracy drops as that list grows, so give the agent only the ones it needs.
 
 ## Error Handling
 
@@ -1589,7 +1540,7 @@ lib/
 │   ├── client.rb            # Main client class
 │   ├── auth.rb              # Auth API (authorization URL + code exchange)
 │   ├── proxy.rb             # Proxy API implementation
-│   ├── mcp.rb               # MCP API (transport + managed sessions)
+│   ├── mcp.rb               # MCP API (transport + hosted)
 │   ├── unify.rb             # Unify API client wrapper
 │   ├── version.rb           # Gem version
 │   ├── resources/

data/lib/bundleup/mcp.rb

@@ -3,11 +3,11 @@
 require 'json'
 
 module BundleUp
-  # Transport for a connection's MCP server.
+  # A connection's MCP server.
   #
-  # +post+ and +delete+ return the raw Faraday response, the way Proxy does.
-  # Use +connect+ for a managed session that handles the handshake and
-  # response decoding.
+  # BundleUp does not ship an MCP client. Hand +transport+ or +hosted+ to the
+  # client you already use, or drive the protocol yourself with +post+ and
+  # +delete+, which return the raw Faraday response the way Proxy does.
   class MCP
     BASE_URL = 'https://mcp.bundleup.io'
 
@@ -47,11 +47,6 @@ module BundleUp
       connection.delete(BASE_URL, nil, default_headers.merge(headers))
     end
 
-    # Open a managed MCP session for this connection.
-    def connect
-      MCPClient.new(BASE_URL, @api_key, @connection_id)
-    end
-
     private
 
     def default_headers
@@ -67,201 +62,4 @@ module BundleUp
       @connection ||= Faraday.new { |faraday| faraday.adapter Faraday.default_adapter }
     end
   end
-
-  # A connected MCP session.
-  #
-  # Tools, resources and prompts are defined by the provider — BundleUp does
-  # not rename or normalize them.
-  class MCPClient
-    PROTOCOL_VERSION = '2025-06-18'
-    CLIENT_NAME = 'bundleup-sdk'
-
-    def initialize(base_url, api_key, connection_id)
-      @base_url = base_url
-      @api_key = api_key
-      @connection_id = connection_id
-      @session_id = nil
-      @connected = false
-      @last_id = 0
-    end
-
-    # List the provider's tools, following pagination to the end.
-    def list_tools
-      paginate('tools/list', 'tools')
-    end
-
-    # Call a tool by name, with arguments matching its own input schema.
-    def call_tool(name, args = {})
-      raise ArgumentError, 'Tool name is required to call a tool.' if blank?(name)
-
-      connect
-      send_message('tools/call', { name: name, arguments: args })
-    end
-
-    # List the provider's resources, following pagination to the end.
-    def list_resources
-      paginate('resources/list', 'resources')
-    end
-
-    # Read a resource by URI.
-    def read_resource(uri)
-      raise ArgumentError, 'Resource URI is required to read a resource.' if blank?(uri)
-
-      connect
-      send_message('resources/read', { uri: uri })
-    end
-
-    # List the provider's prompts, following pagination to the end.
-    def list_prompts
-      paginate('prompts/list', 'prompts')
-    end
-
-    # Get a prompt by name.
-    def get_prompt(name, args = {})
-      raise ArgumentError, 'Prompt name is required to get a prompt.' if blank?(name)
-
-      connect
-      send_message('prompts/get', { name: name, arguments: args })
-    end
-
-    # Send any other JSON-RPC method on this session.
-    def request(method, params = nil)
-      raise ArgumentError, 'Method is required to send a request.' if blank?(method)
-
-      connect
-      send_message(method, params)
-    end
-
-    # End the session and reset local state.
-    def close
-      delete_session if @session_id
-
-      @session_id = nil
-      @connected = false
-      nil
-    end
-
-    private
-
-    def blank?(value)
-      value.nil? || value.to_s.empty?
-    end
-
-    def default_headers
-      headers = {
-        'Authorization' => "Bearer #{@api_key}",
-        'Content-Type' => 'application/json',
-        'Accept' => 'application/json, text/event-stream',
-        'BU-Connection-Id' => @connection_id
-      }
-      headers['Mcp-Session-Id'] = @session_id if @session_id
-      headers
-    end
-
-    def connection
-      @connection ||= Faraday.new { |faraday| faraday.adapter Faraday.default_adapter }
-    end
-
-    def post_payload(payload)
-      response = connection.post(@base_url, payload.to_json, default_headers)
-      session_id = response.headers['mcp-session-id']
-      @session_id = session_id if session_id
-
-      raise error_for(response) unless response.success?
-
-      response
-    end
-
-    def error_for(response)
-      fallback = "MCP request failed with status #{response.status}."
-      parsed = JSON.parse(response.body.to_s)
-      return RuntimeError.new(fallback) unless parsed.is_a?(Hash) && parsed['message']
-
-      code = parsed['code']
-      RuntimeError.new(code ? "#{parsed['message']} (#{code})" : parsed['message'])
-    rescue JSON::ParserError
-      RuntimeError.new(fallback)
-    end
-
-    # Run the MCP handshake, once. Deferred until the first call.
-    def connect
-      return if @connected
-
-      send_message('initialize', handshake_params)
-      post_payload({ jsonrpc: '2.0', method: 'notifications/initialized' })
-      @connected = true
-    end
-
-    def handshake_params
-      {
-        protocolVersion: PROTOCOL_VERSION,
-        capabilities: {},
-        clientInfo: { name: CLIENT_NAME, version: BundleUp::VERSION }
-      }
-    end
-
-    def send_message(method, params = nil)
-      @last_id += 1
-      payload = { jsonrpc: '2.0', id: @last_id, method: method }
-      payload[:params] = params unless params.nil?
-
-      message = parse(post_payload(payload), @last_id)
-      raise "No response received for #{method}." if message.nil?
-      raise message['error']['message'].to_s if message['error']
-
-      message['result'] || {}
-    end
-
-    # Providers may answer a plain request/response over text/event-stream.
-    def parse(response, message_id)
-      body = response.body.to_s
-      return nil if body.empty?
-
-      content_type = response.headers['content-type'].to_s
-      return JSON.parse(body) unless content_type.include?('text/event-stream')
-
-      parse_stream(body, message_id)
-    end
-
-    def parse_stream(body, message_id)
-      body.gsub("\r\n", "\n").split("\n\n").each do |event|
-        data = event_data(event)
-        next if data.empty?
-
-        message = JSON.parse(data)
-        # Skip server notifications interleaved on the stream.
-        return message if message.is_a?(Hash) && message['id'] == message_id
-      end
-
-      nil
-    end
-
-    def event_data(event)
-      event.split("\n")
-           .select { |line| line.start_with?('data:') }
-           .map { |line| line.sub('data:', '').strip }
-           .join("\n")
-    end
-
-    def paginate(method, key)
-      connect
-      items = []
-      cursor = nil
-
-      loop do
-        result = send_message(method, cursor ? { cursor: cursor } : nil)
-        items.concat(result[key] || [])
-        cursor = result['nextCursor']
-        break unless cursor
-      end
-
-      items
-    end
-
-    def delete_session
-      connection.delete(@base_url, nil, default_headers)
-    rescue Faraday::Error
-      nil
-    end
-  end
 end

data/lib/bundleup/unify.rb

@@ -54,11 +54,6 @@ module BundleUp
       def me(params = {})
         (@me ||= BundleUp::Unify::Me.new(api_key, connection_id)).get(params)
       end
-
-      # Access the Unified MCP server for the connection.
-      def mcp
-        @mcp ||= BundleUp::Unify::MCP.new(api_key, connection_id)
-      end
     end
   end
 end

data/lib/bundleup/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module BundleUp
-  VERSION = '0.5.0'
+  VERSION = '0.6.0'
 end

data/lib/bundleup.rb

@@ -23,7 +23,6 @@ require_relative 'bundleup/unify/ticketing'
 require_relative 'bundleup/unify/crm'
 require_relative 'bundleup/unify/drive'
 require_relative 'bundleup/unify/calendar'
-require_relative 'bundleup/unify/mcp'
 require_relative 'bundleup/unify/me'
 
 # Main module for the BundleUp SDK.

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bundleup-sdk
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.6.0
 platform: ruby
 authors:
 - BundleUp
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-09-30 00:00:00.000000000 Z
+date: 2026-10-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
@@ -182,7 +182,6 @@ files:
 - lib/bundleup/unify/crm.rb
 - lib/bundleup/unify/drive.rb
 - lib/bundleup/unify/git.rb
-- lib/bundleup/unify/mcp.rb
 - lib/bundleup/unify/me.rb
 - lib/bundleup/unify/ticketing.rb
 - lib/bundleup/version.rb

data/lib/bundleup/unify/mcp.rb

@@ -1,44 +0,0 @@
-# frozen_string_literal: true
-
-module BundleUp
-  module Unify
-    # The Unified MCP server.
-    #
-    # Same protocol and headers as Proxy MCP, but the tools are BundleUp's
-    # normalized ones rather than the provider's. Tools only — Unified MCP
-    # exposes no resources or prompts.
-    #
-    # The server is stateless and POST-only, so there is no session to close.
-    class MCP
-      BASE_URL = 'https://unify.bundleup.io/v1/mcp'
-
-      attr_reader :api_key, :connection_id
-
-      def initialize(api_key, connection_id)
-        @api_key = api_key
-        @connection_id = connection_id
-        @client = ::BundleUp::MCPClient.new(BASE_URL, api_key, connection_id)
-      end
-
-      # The URL and a single bearer token carrying both the API key and the
-      # connection, for model-hosted MCP clients that cannot set headers.
-      def hosted
-        separator = ::BundleUp::MCP::CREDENTIAL_SEPARATOR
-
-        { url: BASE_URL, token: "#{@api_key}#{separator}#{@connection_id}" }
-      end
-
-      # List the available unified tools.
-      def list_tools
-        @client.list_tools
-      end
-
-      # Call a unified tool with optional arguments.
-      def call_tool(name, args = {})
-        raise ArgumentError, 'Tool name is required to call a tool.' if name.nil? || name.to_s.empty?
-
-        @client.call_tool(name, args)
-      end
-    end
-  end
-end