bundleup-sdk 0.5.0 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ab7e53fa4d67aa688569b213a6b9f090cce9b8e557203e598ef4ce946e4ac508
-  data.tar.gz: 5226846b47d962f8c616eb14e6c47ee8836bde8a63f610cfc155fda1eec879df
+  metadata.gz: a3feaef0f54fcef0ff3dba477b926513d0ed0801e2f383a80b0ca13f44218c5a
+  data.tar.gz: d44bc81b00d6afa88e0b4d58de1f832a98d81538f00a6169d3f5838e52865d1f
 SHA512:
-  metadata.gz: 0a8085e498cfd804bbd5d7b93840997f0d719a4d040d4d0639f2d51621976217b1cfb1038db537e0ca46d917c0440a8ed6b7ab83b3e362c34d45c064dff7a1df
-  data.tar.gz: 823c5ebb016f7c2f31cdae1a838556f2ea7d62a25d0d6193aead188dfe045392cbf940892f258d24a2167fbc5f620816d03274154d07535031c66535c232909d
+  metadata.gz: 95b41fa793e45e3aaa62f01beda29dce8172b5547da1e5959c0c4cf6927de71fca5892f9c2d8d2a87a1fecc3a43af53c7cc2139e1afff4a215f3c5287a057a9d
+  data.tar.gz: e597e588f6cd074e365660d54908ef489e456fcec0b9f5238c87ad946be29b007e636fb541439429fd25a6b6486fa89c535eab2d4c76e5dd824d0427248d8b6d

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
@@ -84,7 +84,7 @@ Runnable examples are available in the [`examples/`](./examples) directory:
 
 - [`examples/basic_usage.rb`](./examples/basic_usage.rb) - Client setup, connections, integrations, and webhooks
 - [`examples/proxy_api.rb`](./examples/proxy_api.rb) - Proxy API GET request with a connection
-- [`examples/unify_api.rb`](./examples/unify_api.rb) - Unify Chat, Git, PM, Ticketing, Drive, and Calendar endpoint usage
+- [`examples/unify_api.rb`](./examples/unify_api.rb) - Unify Chat, Git, Tasks, Helpdesk, Drive, and Calendar endpoint usage
 - [`examples/README.md`](./examples/README.md) - Setup and execution instructions
 
 ## Quick Start
@@ -542,6 +542,16 @@ url = client.auth.build_authorization_url(
 # Redirect the user to `url`
 ```
 
+The URL needs no API key, so you can also build it without a client:
+
+```ruby
+url = BundleUp.build_authorization_url(
+  client_id: 'your-client-id',
+  integration_id: 'github',
+  redirect_uri: 'https://app.example.com/callback'
+)
+```
+
 **Parameters:**
 
 - `client_id` (String, required): Your workspace client ID
@@ -1084,20 +1094,20 @@ provider's default branch is used.
 }
 ```
 
-#### Ticketing API
+#### Tasks API
 
-The Ticketing API provides a unified interface for ticketing and project management platforms like Jira, Linear, and Asana.
+The Tasks API provides a unified interface for issue trackers and project management tools like Jira, Linear, Asana, Trello, ClickUp, monday.com, Basecamp, Wrike, and Todoist.
 
-##### List Tickets
+##### List Tasks
 
 ```ruby
-result = unify.ticketing.tickets(
+result = unify.tasks.tasks(
   limit: 100,
   after: nil,
   include_raw: false
 )
 
-puts "Tickets: #{result['data']}"
+puts "Tasks: #{result['data']}"
 ```
 
 **Response:**
@@ -1124,18 +1134,18 @@ puts "Tickets: #{result['data']}"
 **Filtering and sorting:**
 
 ```ruby
-open_tickets = result['data'].select { |ticket| ticket['status'] == 'open' }
-sorted_by_date = result['data'].sort_by { |ticket| Time.parse(ticket['created_at']) }.reverse
+open_tasks = result['data'].select { |task| task['status'] == 'open' }
+sorted_by_date = result['data'].sort_by { |task| Time.parse(task['created_at']) }.reverse
 ```
 
-##### Get a Ticket
+##### Get a Task
 
-Fetch one ticket by ID. Not supported by Basecamp, whose API only serves a to-do underneath its project.
+Fetch one task by ID. Not supported by Basecamp, whose API only serves a to-do underneath its project.
 
 ```ruby
-result = unify.ticketing.ticket('PROJ-123')
+result = unify.tasks.task('PROJ-123')
 
-puts "Ticket: #{result['data']}"
+puts "Task: #{result['data']}"
 ```
 
 **Response:**
@@ -1159,7 +1169,7 @@ A single resource carries no pagination, so there is no `metadata` on this respo
 ##### List Projects
 
 ```ruby
-result = unify.ticketing.projects(
+result = unify.tasks.projects(
   limit: 100,
   after: nil,
   include_raw: false
@@ -1191,6 +1201,57 @@ puts "Projects: #{result['data']}"
 
 **Note:** Not every platform returns every field. Jira does not expose creation or update timestamps for projects, so `created_at` and `updated_at` are `nil` for Jira connections, and `status` is only set when Jira reports whether the project is archived.
 
+#### Helpdesk API
+
+The Helpdesk API provides a unified interface for customer support tools like Zendesk, ServiceNow, Zoho Desk, Gorgias, and Help Scout.
+
+##### List Tickets
+
+```ruby
+result = unify.helpdesk.tickets(
+  limit: 100,
+  after: nil,
+  include_raw: false
+)
+
+puts "Tickets: #{result['data']}"
+```
+
+**Response:**
+
+```ruby
+{
+  'data' => [
+    {
+      'id' => '4182',
+      'title' => 'Refund for order #1043',
+      'description' => 'Hi, my order arrived damaged...',
+      'status' => 'open',
+      'priority' => 'high',
+      'requester' => { 'id' => '381920', 'name' => 'Dana Ruiz', 'email' => 'dana@example.com' },
+      'url' => 'https://acme.zendesk.com/agent/tickets/4182',
+      'created_at' => '2024-01-15T10:30:00Z',
+      'updated_at' => '2024-01-20T14:22:00Z'
+    }
+  ],
+  'metadata' => {
+    'next' => 'cursor_def456'
+  }
+}
+```
+
+##### Get a Ticket
+
+Fetch one support ticket by ID. On ServiceNow the ID is the incident's `sys_id`.
+
+```ruby
+result = unify.helpdesk.ticket('4182')
+
+puts "Ticket: #{result['data']}"
+```
+
+A single resource carries no pagination, so there is no `metadata` on this response.
+
 #### CRM API
 
 The CRM API provides a unified interface for CRM platforms like Attio, HubSpot, PipeDrive, Salesforce and Zoho.
@@ -1340,47 +1401,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 +1431,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 +1534,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 +1601,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/
@@ -1601,7 +1613,8 @@ lib/
 │       ├── base.rb          # Base Unify class
 │       ├── chat.rb          # Chat Unify API
 │       ├── git.rb           # Git Unify API
-│       ├── ticketing.rb     # Ticketing Unify API
+│       ├── tasks.rb         # Tasks Unify API
+│       ├── helpdesk.rb      # Helpdesk Unify API
 │       ├── crm.rb           # CRM Unify API
 │       ├── drive.rb         # Drive Unify API
 │       └── calendar.rb      # Calendar Unify API

data/lib/bundleup/auth.rb

@@ -14,7 +14,10 @@ module BundleUp
     end
 
     # Builds the hosted authorization URL to send the end user to.
-    def build_authorization_url(client_id:, integration_id:, redirect_uri:, external_id: nil, state: nil)
+    #
+    # Needs no API key: /authorize only takes the public client and
+    # integration ids, so this is safe to call where the key must not live.
+    def self.build_authorization_url(client_id:, integration_id:, redirect_uri:, external_id: nil, state: nil)
       raise ArgumentError, 'client_id is required' if blank?(client_id)
       raise ArgumentError, 'integration_id is required' if blank?(integration_id)
       raise ArgumentError, 'redirect_uri is required' if blank?(redirect_uri)
@@ -30,6 +33,16 @@ module BundleUp
       "#{BASE_URL}/authorize?#{URI.encode_www_form(params)}"
     end
 
+    def self.blank?(value)
+      value.nil? || value.to_s.empty?
+    end
+    private_class_method :blank?
+
+    # Builds the hosted authorization URL to send the end user to.
+    def build_authorization_url(**params)
+      self.class.build_authorization_url(**params)
+    end
+
     # Exchanges the one-time code from the redirect for the connection.
     # Call this server-side; the code expires after 5 minutes and works once.
     # Returns { 'connection_id', 'external_id', 'integration_id' }.

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/helpdesk.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module BundleUp
+  module Unify
+    # Client for helpdesk Unify endpoints (customer support tools).
+    class Helpdesk < Base
+      # Fetches support tickets from the connected helpdesk.
+      def tickets(params = {})
+        response = connection.get('helpdesk/tickets') do |req|
+          req.params = params
+        end
+
+        raise "Failed to fetch helpdesk/tickets: #{response.status}" unless response.success?
+
+        response.body
+      end
+
+      # Fetches a single support ticket by ID (a sys_id on ServiceNow).
+      def ticket(ticket_id, params = {})
+        raise ArgumentError, 'ticket_id is required to fetch a ticket.' if blank?(ticket_id)
+
+        encoded_id = URI.encode_www_form_component(ticket_id)
+
+        response = connection.get("helpdesk/tickets/#{encoded_id}") do |req|
+          req.params = params
+        end
+
+        raise "Failed to fetch helpdesk/tickets/#{encoded_id}: #{response.status}" unless response.success?
+
+        response.body
+      end
+
+      private
+
+      def blank?(value)
+        value.nil? || value.to_s.empty?
+      end
+    end
+  end
+end

data/lib/bundleup/unify/tasks.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module BundleUp
+  module Unify
+    # Client for tasks Unify endpoints (issue trackers and project tools).
+    class Tasks < Base
+      # Fetches tasks from the connected issue tracker or project tool.
+      def tasks(params = {})
+        response = connection.get('tasks/tasks') do |req|
+          req.params = params
+        end
+
+        raise "Failed to fetch tasks/tasks: #{response.status}" unless response.success?
+
+        response.body
+      end
+
+      # Fetches a single task by ID from the connected issue tracker or project tool.
+      #
+      # Not supported by Basecamp, whose API only serves a to-do underneath its
+      # project — an id on its own cannot address one.
+      def task(task_id, params = {})
+        raise ArgumentError, 'task_id is required to fetch a task.' if blank?(task_id)
+
+        encoded_id = URI.encode_www_form_component(task_id)
+
+        response = connection.get("tasks/tasks/#{encoded_id}") do |req|
+          req.params = params
+        end
+
+        raise "Failed to fetch tasks/tasks/#{encoded_id}: #{response.status}" unless response.success?
+
+        response.body
+      end
+
+      # Fetches projects from the connected issue tracker or project tool.
+      def projects(params = {})
+        response = connection.get('tasks/projects') do |req|
+          req.params = params
+        end
+
+        raise "Failed to fetch tasks/projects: #{response.status}" unless response.success?
+
+        response.body
+      end
+
+      private
+
+      def blank?(value)
+        value.nil? || value.to_s.empty?
+      end
+    end
+  end
+end

data/lib/bundleup/unify.rb

@@ -7,7 +7,8 @@ module BundleUp
       attr_reader :api_key, :connection_id
 
       def initialize(api_key, connection_id)
-        @ticketing = BundleUp::Unify::Ticketing.new(api_key, connection_id)
+        @tasks = BundleUp::Unify::Tasks.new(api_key, connection_id)
+        @helpdesk = BundleUp::Unify::Helpdesk.new(api_key, connection_id)
         @chat = BundleUp::Unify::Chat.new(api_key, connection_id)
         @git = BundleUp::Unify::Git.new(api_key, connection_id)
         @crm = BundleUp::Unify::CRM.new(api_key, connection_id)
@@ -32,9 +33,14 @@ module BundleUp
         @crm ||= BundleUp::Unify::CRM.new(api_key, connection_id)
       end
 
-      # Access the Ticketing API for the connection.
-      def ticketing
-        @ticketing ||= BundleUp::Unify::Ticketing.new(api_key, connection_id)
+      # Access the Tasks API (issue trackers and project tools) for the connection.
+      def tasks
+        @tasks ||= BundleUp::Unify::Tasks.new(api_key, connection_id)
+      end
+
+      # Access the Helpdesk API (customer support tools) for the connection.
+      def helpdesk
+        @helpdesk ||= BundleUp::Unify::Helpdesk.new(api_key, connection_id)
       end
 
       # Access the Drive API for the connection.
@@ -54,11 +60,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.7.0'
 end

data/lib/bundleup.rb

@@ -19,13 +19,18 @@ require_relative 'bundleup/resources/webhook'
 require_relative 'bundleup/unify/base'
 require_relative 'bundleup/unify/chat'
 require_relative 'bundleup/unify/git'
-require_relative 'bundleup/unify/ticketing'
+require_relative 'bundleup/unify/tasks'
+require_relative 'bundleup/unify/helpdesk'
 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.
 module BundleUp
+  # Builds the hosted authorization URL without an API key.
+  # See BundleUp::Auth.build_authorization_url.
+  def self.build_authorization_url(**params)
+    Auth.build_authorization_url(**params)
+  end
 end

data/sig/bundleup/auth.rbs

@@ -1,4 +1,12 @@
 module BundleUp
+  def self.build_authorization_url: (
+    client_id: String,
+    integration_id: String,
+    redirect_uri: String,
+    ?external_id: String?,
+    ?state: String?
+  ) -> String
+
   class Auth
     BASE_URL: String
 
@@ -12,6 +20,16 @@ module BundleUp
 
     def initialize: (String api_key) -> void
 
+    def self.blank?: (untyped value) -> bool
+
+    def self.build_authorization_url: (
+      client_id: String,
+      integration_id: String,
+      redirect_uri: String,
+      ?external_id: String?,
+      ?state: String?
+    ) -> String
+
     def build_authorization_url: (
       client_id: String,
       integration_id: String,

data/sig/bundleup/unify/helpdesk.rbs

@@ -0,0 +1,33 @@
+module BundleUp
+  module Unify
+    class Helpdesk < Base
+      type requester = {
+        id: String?,
+        name: String?,
+        email: String?
+      }
+
+      type ticket = {
+        id: String,
+        title: String?,
+        description: String?,
+        status: String?,
+        priority: String?,
+        requester: requester?,
+        url: String?,
+        created_at: String?,
+        updated_at: String?
+      }
+
+      type metadata = { next: String? }
+
+      def tickets: (?Hash[Symbol, untyped] params) -> { data: Array[ticket], metadata: metadata }
+
+      def ticket: (String ticket_id, ?Hash[Symbol, untyped] params) -> { data: ticket }
+
+      private
+
+      def blank?: (untyped) -> bool
+    end
+  end
+end

data/sig/bundleup/unify/{ticketing.rbs → tasks.rbs}

@@ -1,7 +1,7 @@
 module BundleUp
   module Unify
-    class Ticketing < Base
-      type ticketing_ticket = {
+    class Tasks < Base
+      type task_item = {
         id: String,
         title: String,
         status: String,
@@ -11,7 +11,7 @@ module BundleUp
         updated_at: String
       }
 
-      type ticket = {
+      type task = {
         id: String,
         title: String,
         status: String?,
@@ -21,7 +21,7 @@ module BundleUp
         updated_at: String?
       }
 
-      type ticketing_project = {
+      type project = {
         id: String,
         name: String,
         status: String?,
@@ -33,11 +33,11 @@ module BundleUp
 
       type metadata = { next: String? }
 
-      def tickets: (?Hash[Symbol, untyped] params) -> { data: Array[ticketing_ticket], metadata: metadata }
+      def tasks: (?Hash[Symbol, untyped] params) -> { data: Array[task_item], metadata: metadata }
 
-      def ticket: (String ticket_id, ?Hash[Symbol, untyped] params) -> { data: ticket }
+      def task: (String task_id, ?Hash[Symbol, untyped] params) -> { data: task }
 
-      def projects: (?Hash[Symbol, untyped] params) -> { data: Array[ticketing_project], metadata: metadata }
+      def projects: (?Hash[Symbol, untyped] params) -> { data: Array[project], metadata: metadata }
 
       private
 

data/sig/bundleup/unify.rbs

@@ -8,7 +8,8 @@ module BundleUp
 
       def chat: () -> Chat
       def git: () -> Git
-      def ticketing: () -> Ticketing
+      def tasks: () -> Tasks
+      def helpdesk: () -> Helpdesk
       def crm: () -> CRM
       def drive: () -> Drive
       def calendar: () -> Calendar

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bundleup-sdk
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.7.0
 platform: ruby
 authors:
 - BundleUp
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-09-30 00:00:00.000000000 Z
+date: 2026-10-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
@@ -182,9 +182,9 @@ files:
 - lib/bundleup/unify/crm.rb
 - lib/bundleup/unify/drive.rb
 - lib/bundleup/unify/git.rb
-- lib/bundleup/unify/mcp.rb
+- lib/bundleup/unify/helpdesk.rb
 - lib/bundleup/unify/me.rb
-- lib/bundleup/unify/ticketing.rb
+- lib/bundleup/unify/tasks.rb
 - lib/bundleup/version.rb
 - sig/bundleup/auth.rbs
 - sig/bundleup/unify.rbs
@@ -194,8 +194,9 @@ files:
 - sig/bundleup/unify/crm.rbs
 - sig/bundleup/unify/drive.rbs
 - sig/bundleup/unify/git.rbs
+- sig/bundleup/unify/helpdesk.rbs
 - sig/bundleup/unify/me.rbs
-- sig/bundleup/unify/ticketing.rbs
+- sig/bundleup/unify/tasks.rbs
 homepage: https://github.com/bundleup/bundleup-sdk-ruby
 licenses:
 - MIT

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

data/lib/bundleup/unify/ticketing.rb

@@ -1,54 +0,0 @@
-# frozen_string_literal: true
-
-module BundleUp
-  module Unify
-    # Client for ticketing Unify endpoints.
-    class Ticketing < Base
-      # Fetches tickets from the connected ticketing tool.
-      def tickets(params = {})
-        response = connection.get('ticketing/tickets') do |req|
-          req.params = params
-        end
-
-        raise "Failed to fetch ticketing/tickets: #{response.status}" unless response.success?
-
-        response.body
-      end
-
-      # Fetches a single ticket by ID from the connected ticketing tool.
-      #
-      # Not supported by Basecamp, whose API only serves a to-do underneath its
-      # project — an id on its own cannot address one.
-      def ticket(ticket_id, params = {})
-        raise ArgumentError, 'ticket_id is required to fetch a ticket.' if blank?(ticket_id)
-
-        encoded_id = URI.encode_www_form_component(ticket_id)
-
-        response = connection.get("ticketing/tickets/#{encoded_id}") do |req|
-          req.params = params
-        end
-
-        raise "Failed to fetch ticketing/tickets/#{encoded_id}: #{response.status}" unless response.success?
-
-        response.body
-      end
-
-      # Fetches projects from the connected ticketing tool.
-      def projects(params = {})
-        response = connection.get('ticketing/projects') do |req|
-          req.params = params
-        end
-
-        raise "Failed to fetch ticketing/projects: #{response.status}" unless response.success?
-
-        response.body
-      end
-
-      private
-
-      def blank?(value)
-        value.nil? || value.to_s.empty?
-      end
-    end
-  end
-end