model-context-protocol-rb 0.5.0 → 0.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5f97580e7f9c5723d25472b545c037bad650d82434865324c6d1dd450ac4031e
-  data.tar.gz: 1b73ad6036c7ded852210dc338190675e419c6f6354e027d2b7073a5e655c665
+  metadata.gz: 8fd0681c65b47196375ec7f4934cadf226ed01b1b289caf296348698808ef5cb
+  data.tar.gz: 4ce234855d56b724b6f69b97851ff1ee4db65370b7361ea0a65c43a929c448b7
 SHA512:
-  metadata.gz: 3075cfc900a60fd1cb83b973c23f6f517373f6132ab043ea64079653bbc0ecc5c5aeb8a077e2c685396f9921d80ad341f9fa271fd343fb9b9f29ce93b6abda4b
-  data.tar.gz: c72619fea381f8968d7dd33e60c306449973bbeda9f5a8ffd6b8d5baf95d26df8278a2106b82daeef61982a950b74b5f168a8afb680baa6e44f10d26626cac69
+  metadata.gz: b3bafa3fe92aa05ff380ad5fc311c0143d5e1bb6c3a91e50893115eb01ad2ea8b2d93dde89240815b50629fcb3b3b3467585766ac42d2c7087cd0be55b431455
+  data.tar.gz: 9d1c4f1c5f93352bf9392f9aeaf63253534348787aecb0866abe160dbf7cebc302bfec751955b19d0a06d9d60675c450960d401af2538aa9b100fe076bc7fd94

data/CHANGELOG.md

@@ -1,5 +1,9 @@
 ## [Unreleased]
 
+## [0.5.1] - 2025-09-23
+
+- (Fix) Ensure streams are properly closed when clients disconnect.
+
 ## [0.5.0] - 2025-09-22
 
 - Make streamable HTTP transport thread-safe by using Redis to manage state.
@@ -75,6 +79,7 @@
 - Initial release
 
 [Unreleased]: https://github.com/dickdavis/model-context-protocol-rb/compare/v0.5.0...HEAD
+[0.5.1]: https://github.com/dickdavis/model-context-protocol-rb/compare/v0.5.0...v0.5.1
 [0.5.0]: https://github.com/dickdavis/model-context-protocol-rb/compare/v0.4.0...v0.5.0
 [0.4.0]: https://github.com/dickdavis/model-context-protocol-rb/compare/v0.3.4...v0.4.0
 [0.3.4]: https://github.com/dickdavis/model-context-protocol-rb/compare/v0.3.3...v0.3.4

data/README.md

@@ -7,24 +7,20 @@ Provides simple abstractions that allow you to serve prompts, resources, resourc
 ## Table of Contents
 
 - [Feature Support (Server)](#feature-support-server)
-- [Usage](#usage)
-  - [Building an MCP Server](#building-an-mcp-server)
-    - [Server Configuration Options](#server-configuration-options)
-    - [Pagination Configuration Options](#pagination-configuration-options)
-    - [Transport Configuration Options](#transport-configuration-options)
-      - [STDIO Transport](#stdio-transport)
-      - [Streamable HTTP Transport](#streamable-http-transport)
-    - [Registry Configuration Options](#registry-configuration-options)
-  - [Integration with Rails](#integration-with-rails)
-  - [Server features](#server-features)
-    - [Prompts](#prompts)
-    - [Resources](#resources)
-    - [Resource Templates](#resource-templates)
-    - [Tools](#tools)
-    - [Completions](#completions)
+- [Quick Start with Rails](#quick-start-with-rails)
 - [Installation](#installation)
+- [Building an MCP Server](#building-an-mcp-server)
+  - [Server Configuration Options](#server-configuration-options)
+  - [Pagination Configuration Options](#pagination-configuration-options)
+  - [Transport Configuration Options](#transport-configuration-options)
+  - [Redis Configuration](#redis-configuration)
+  - [Registry Configuration Options](#registry-configuration-options)
+- [Prompts](#prompts)
+- [Resources](#resources)
+- [Resource Templates](#resource-templates)
+- [Tools](#tools)
+- [Completions](#completions)
 - [Development](#development)
-  - [Releases](#releases)
 - [Contributing](#contributing)
 - [License](#license)
 
@@ -50,15 +46,144 @@ Provides simple abstractions that allow you to serve prompts, resources, resourc
 | ✅ | [Ping](https://modelcontextprotocol.io/specification/2025-06-18/basic/utilities/ping) |
 | ✅ | [Progress](https://modelcontextprotocol.io/specification/2025-06-18/basic/utilities/progress) |
 
-## Usage
+## Quick Start with Rails
 
-Include `model_context_protocol` in your project.
+The `model-context-protocol-rb` works out of the box with any valid Rack request. Currently, this project has no plans for building a deeper Rails integration, but it is fairly simple to build it out yourself. To support modern application deployments across multiple servers, the streamable HTTP transport requires Redis as an external dependency.
+
+Here's an example of how you can easily integrate with Rails.
+
+First, configure Redis in an initializer:
 
 ```ruby
-require 'model_context_protocol'
+# config/initializers/model_context_protocol.rb
+require "model_context_protocol"
+
+ModelContextProtocol::Server.configure_redis do |config|
+  config.redis_url = ENV.fetch("REDIS_URL", "redis://localhost:6379/0")
+  config.pool_size = 20
+  config.pool_timeout = 5
+  config.enable_reaper = true
+  config.reaper_interval = 60
+  config.idle_timeout = 300
+end
 ```
 
-### Building an MCP Server
+Then, set the routes:
+
+```ruby
+constraints format: :json do
+  get "/mcp", to: "model_context_protocol#handle", as: :mcp_get
+  post "/mcp", to: "model_context_protocol#handle", as: :mcp_post
+  delete "/mcp", to: "model_context_protocol#handle", as: :mcp_delete
+end
+```
+
+Then, implement a controller endpoint to handle the requests.
+
+```ruby
+class ModelContextProtocolController < ActionController::API
+  include ActionController::Live
+
+  before_action :authenticate_user
+
+  def handle
+    server = ModelContextProtocol::Server.new do |config|
+      config.name = "MyMCPServer"
+      config.title = "My MCP Server"
+      config.version = "1.0.0"
+      config.logging_enabled = true
+      config.registry = build_registry
+      config.context = {
+        user_id: current_user.id,
+        request_id: request.id
+      }
+      config.transport = {
+        type: :streamable_http,
+        env: request.env
+      }
+      config.instructions = <<~INSTRUCTIONS
+        This server provides prompts, tools, and resources for interacting with my app.
+
+        Key capabilities:
+        - Does this one thing
+        - Does this other thing
+        - Oh, yeah, and it does that one thing, too
+
+        Use this server when you need to do stuff.
+      INSTRUCTIONS
+    end
+
+    result = server.start
+    handle_mcp_response(result)
+  end
+
+  private
+
+  def build_registry
+    ModelContextProtocol::Server::Registry.new do
+      tools do
+        # Implement user authorization logic to dynamically build registry
+        register TestTool if current_user.authorized_for?(TestTool)
+      end
+    end
+  end
+
+  def handle_mcp_response(result)
+    if result[:headers]&.dig("Content-Type") == "text/event-stream"
+      setup_streaming_headers
+      stream_response(result[:stream_proc])
+    else
+      render_json_response(result)
+    end
+  end
+
+  def setup_streaming_headers
+    response.headers.merge!(
+      "Content-Type" => "text/event-stream",
+      "Cache-Control" => "no-cache",
+      "Connection" => "keep-alive"
+    )
+  end
+
+  def stream_response(stream_proc)
+    stream_proc&.call(response.stream)
+  ensure
+    response.stream.close rescue nil
+  end
+
+  def render_json_response(result)
+    render json: result[:json],
+      status: result[:status] || 200,
+      headers: result[:headers] || {}
+  end
+end
+```
+
+Read more about the [server configuration options](building-an-mcp-server) to better understand how you can customize your MCP server.
+
+From here, you can get started building [prompts](#prompts), [resources](#resources), [resource templates](#resource-templates), and [tools](#tools).
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'model-context-protocol-rb'
+```
+
+And then execute:
+
+```bash
+bundle
+```
+
+Or install it yourself as:
+
+```bash
+gem install model-context-protocol-rb
+```
+
+## Building an MCP Server
 
 Build a simple MCP server by registering your prompts, resources, resource templates, and tools. Then, configure and run the server. Messages from the MCP client will be routed to the appropriate custom handler. This SDK provides several classes that should be used to build your handlers.
 
@@ -146,7 +271,7 @@ end
 server.start
 ```
 
-#### Server Configuration Options
+### Server Configuration Options
 
 The following table details all available configuration options for the MCP server:
 
@@ -162,7 +287,7 @@ The following table details all available configuration options for the MCP serv
 | `transport` | Hash | No | `{ type: :stdio }` | Transport configuration |
 | `registry` | Registry | Yes | - | Registry containing prompts, resources, and tools |
 
-#### Pagination Configuration Options
+### Pagination Configuration Options
 
 When `pagination` is set to a Hash, the following options are available:
 
@@ -174,16 +299,32 @@ When `pagination` is set to a Hash, the following options are available:
 
 **Note:** Set `config.pagination = false` to completely disable pagination support.
 
-#### Transport Configuration Options
+### Transport Configuration Options
 
 The transport configuration supports two types: `:stdio` (default) and `:streamable_http`.
 
-##### STDIO Transport
+#### STDIO Transport
+
 ```ruby
 config.transport = { type: :stdio }  # This is the default, can be omitted
 ```
 
-##### Streamable HTTP Transport
+#### Streamable HTTP Transport
+
+```ruby
+config.transport = { type: :streamable_http, env: request.env }
+```
+
+When using `:streamable_http` transport, the following options are available:
+
+| Option | Type | Required | Default | Description |
+|--------|------|----------|---------|-------------|
+| `type` | Symbol | Yes | `:stdio` | Must be `:streamable_http` for HTTP transport |
+| `session_ttl` | Integer | No | `3600` | Session timeout in seconds (1 hour) |
+| `env` | Hash | No | - | Rack environment hash (for Rails integration) |
+
+### Redis Configuration
+
 The `:streamable_http` transport requires Redis to be configured globally before use:
 
 ```ruby
@@ -206,15 +347,7 @@ end
 | `reaper_interval` | Integer | No | `60` | Reaper check interval in seconds |
 | `idle_timeout` | Integer | No | `300` | Idle connection timeout in seconds |
 
-When using `:streamable_http` transport, the following options are available:
-
-| Option | Type | Required | Default | Description |
-|--------|------|----------|---------|-------------|
-| `type` | Symbol | Yes | `:stdio` | Must be `:streamable_http` for HTTP transport |
-| `session_ttl` | Integer | No | `3600` | Session timeout in seconds (1 hour) |
-| `env` | Hash | No | - | Rack environment hash (for Rails integration) |
-
-#### Registry Configuration Options
+### Registry Configuration Options
 
 The registry is configured using `ModelContextProtocol::Server::Registry.new` and supports the following block types:
 
@@ -245,96 +378,9 @@ config.registry = ModelContextProtocol::Server::Registry.new do
 end
 ```
 
-#### Integration with Rails
-
-The streamable HTTP transport works with any valid Rack request. Here's an example of how you can integrate with Rails.
+---
 
-First, configure Redis in an initializer:
-
-```ruby
-# config/initializers/model_context_protocol.rb
-ModelContextProtocol::Server.configure_redis do |config|
-  config.redis_url = ENV.fetch('REDIS_URL')
-  config.pool_size = 20
-  config.pool_timeout = 5
-  config.enable_reaper = true
-  config.reaper_interval = 60
-  config.idle_timeout = 300
-end
-```
-
-Then, set the routes:
-
-```ruby
-constraints format: :json do
-  get "/mcp", to: "model_context_protocol#handle", as: :mcp_get
-  post "/mcp", to: "model_context_protocol#handle", as: :mcp_post
-  delete "/mcp", to: "model_context_protocol#handle", as: :mcp_delete
-end
-```
-
-Then, implement a controller endpoint to handle the requests.
-
-```ruby
-require 'model_context_protocol'
-
-class ModelContextProtocolController < ApplicationController
-  before_action :authenticate_user
-
-  def handle
-    server = ModelContextProtocol::Server.new do |config|
-      config.name = "MyMCPServer"
-      config.title = "My MCP Server"
-      config.version = "1.0.0"
-      config.logging_enabled = true
-      config.context = {
-        user_id: current_user.id,
-        request_id: request.id
-      }
-      config.registry = build_registry
-      config.transport = {
-        type: :streamable_http,
-        env: request.env
-      }
-      config.instructions = <<~INSTRUCTIONS
-        This server provides prompts, tools, and resources for interacting with my app.
-
-        Key capabilities:
-        - Does this one thing
-        - Does this other thing
-        - Oh, yeah, and it does that one thing, too
-
-        Use this server when you need to do stuff.
-      INSTRUCTIONS
-    end
-
-    result = server.start
-
-    # For SSE responses
-    if result[:stream]
-      response.headers.merge!(result[:headers] || {})
-      response.content_type = result[:headers]["Content-Type"] || "text/event-stream"
-      # Handle streaming with result[:stream_proc]
-    else
-      # For regular JSON responses
-      render json: result[:json], status: result[:status], headers: result[:headers]
-    end
-  end
-
-  private
-
-  def build_registry
-    ModelContextProtocol::Server::Registry.new do
-      tools do
-        # Implement user authorization logic to dynamically build registry
-        register TestTool if current_user.authorized_for?(TestTool)
-      end
-    end
-  end
-end
-```
-
-### Prompts
+## Prompts
 
 The `ModelContextProtocol::Server::Prompt` base class allows subclasses to define a prompt that the MCP client can use.
 
@@ -342,7 +388,7 @@ Define the prompt properties and then implement the `call` method to build your
 
 You can also log from within your prompt by calling a valid logger level method on the `logger` and passing a string message.
 
-#### Prompt Definition
+### Prompt Definition
 
 Use the `define` block to set [prompt properties](https://spec.modelcontextprotocol.io/specification/2025-06-18/server/prompts/) and configure arguments.
 
@@ -353,7 +399,7 @@ Use the `define` block to set [prompt properties](https://spec.modelcontextproto
 | `description` | Short description of what the prompt does |
 | `argument` | Define an argument block with name, description, required flag, and completion |
 
-#### Argument Definition
+### Argument Definition
 
 Define any arguments using `argument` blocks nested within the `define` block. You can mark an argument as required, and you can optionally provide a completion class. See [Completions](#completions) for more information.
 
@@ -364,7 +410,7 @@ Define any arguments using `argument` blocks nested within the `define` block. Y
 | `required` | Whether the argument is required (boolean) |
 | `completion` | Available hints for completions (array or completion class) |
 
-#### Prompt Methods
+### Prompt Methods
 
 Define your prompt properties and arguments, implement the `call` method using the `message_history` DSL to build prompt messages and `respond_with` to serialize them. You can wrap long running operations in a `cancellable` block to allow clients to cancel the request. Also, you can automatically send progress notifications to clients by wrapping long-running operations in a `progressable` block.
 
@@ -377,7 +423,7 @@ Define your prompt properties and arguments, implement the `call` method using t
 | `message_history` | Within `call` | DSL method to build an array of user and assistant messages |
 | `respond_with` | Within `call` | Return properly formatted response data (e.g., `respond_with messages:`) |
 
-#### Message History DSL
+### Message History DSL
 
 Build a message history using the an intuitive DSL, creating an ordered history of user and assistant messages with flexible content blocks that can include text, image, audio, embedded resources, and resource links.
 
@@ -386,7 +432,7 @@ Build a message history using the an intuitive DSL, creating an ordered history
 | `user_message` | Within `message_history` | Create a message with user role |
 | `assistant_message` | Within `message_history` | Create a message with assistant role |
 
-#### Content Blocks
+### Content Blocks
 
 Use content blocks to properly format the content included in messages.
 
@@ -398,7 +444,7 @@ Use content blocks to properly format the content included in messages.
 | `embedded_resource_content` | Within message blocks | Create embedded resource content block (requires `resource:`) |
 | `resource_link` | Within message blocks | Create resource link content block (requires `name:` and `uri:`) |
 
-#### Available Instance Variables
+### Available Instance Variables
 
 The `arguments` passed from an MCP client are available, as well as the `context` values passed in at server initialization.
 
@@ -408,7 +454,7 @@ The `arguments` passed from an MCP client are available, as well as the `context
 | `context` | Within `call` | Hash containing server configuration context values |
 | `logger` | Within `call` | Logger instance for logging (e.g., `logger.info("message")`) |
 
-#### Examples
+### Examples
 
 This is an example prompt that returns a properly formatted response:
 
@@ -487,13 +533,15 @@ class TestPrompt < ModelContextProtocol::Server::Prompt
 end
 ```
 
-### Resources
+---
+
+## Resources
 
 The `ModelContextProtocol::Server::Resource` base class allows subclasses to define a resource that the MCP client can use.
 
 Define the resource properties and optionally annotations, then implement the `call` method to build your resource. Use the `respond_with` instance method to ensure your resource responds with appropriately formatted response data.
 
-#### Resource Definition
+### Resource Definition
 
 Use the `define` block to set [resource properties](https://spec.modelcontextprotocol.io/specification/2025-06-18/server/resources/) and configure annotations.
 
@@ -506,7 +554,7 @@ Use the `define` block to set [resource properties](https://spec.modelcontextpro
 | `uri` | URI identifier for the resource |
 | `annotations` | Block for defining resource annotations |
 
-#### Annotation Definition
+### Annotation Definition
 
 Define any [resource annotations](https://modelcontextprotocol.io/specification/2025-06-18/server/resources#annotations) using an `annotations` block nested within the `define` block.
 
@@ -516,7 +564,7 @@ Define any [resource annotations](https://modelcontextprotocol.io/specification/
 | `priority` | Priority level (numeric value, e.g., `0.9`) |
 | `last_modified` | Last modified timestamp (ISO 8601 string) |
 
-#### Resource Methods
+### Resource Methods
 
 Define your resource properties and annotations, implement the `call` method to build resource content and `respond_with` to serialize the response. You can wrap long running operations in a `cancellable` block to allow clients to cancel the request. Also, you can automatically send progress notifications to clients by wrapping long-running operations in a `progressable` block.
 
@@ -528,7 +576,7 @@ Define your resource properties and annotations, implement the `call` method to
 | `progressable` | Within `call` | Wrap long-running operations to send clients progress notifications (e.g., `progressable { slow_operation }`) |
 | `respond_with` | Within `call` | Return properly formatted response data (e.g., `respond_with text:` or `respond_with binary:`) |
 
-#### Available Instance Variables
+### Available Instance Variables
 
 Resources are stateless and only have access to their configured properties.
 
@@ -537,7 +585,7 @@ Resources are stateless and only have access to their configured properties.
 | `mime_type` | Within `call` | The configured MIME type for this resource |
 | `uri` | Within `call` | The configured URI identifier for this resource |
 
-#### Examples
+### Examples
 
 This is an example resource that returns a text response:
 
@@ -599,13 +647,15 @@ class TestBinaryResource < ModelContextProtocol::Server::Resource
 end
 ```
 
-### Resource Templates
+---
+
+## Resource Templates
 
 The `ModelContextProtocol::Server::ResourceTemplate` base class allows subclasses to define a resource template that the MCP client can use.
 
 Define the resource template properties and URI template with optional parameter completions. Resource templates are used to define parameterized resources that clients can instantiate.
 
-#### Resource Template Definition
+### Resource Template Definition
 
 Use the `define` block to set [resource template properties](https://modelcontextprotocol.io/specification/2025-06-18/server/resources#resource-templates).
 
@@ -616,7 +666,7 @@ Use the `define` block to set [resource template properties](https://modelcontex
 | `mime_type` | MIME type of resources created from this template |
 | `uri_template` | URI template with parameters (e.g., `"file:///{name}"`) |
 
-#### URI Template Configuration
+### URI Template Configuration
 
 Define the URI template and configure parameter completions within the `uri_template` block.
 
@@ -624,7 +674,7 @@ Define the URI template and configure parameter completions within the `uri_temp
 |--------|---------|-------------|
 | `completion` | Within `uri_template` block | Define completion for a URI parameter (e.g., `completion :name, ["value1", "value2"]`) |
 
-#### Resource Template Methods
+### Resource Template Methods
 
 Resource templates only use the `define` method to configure their properties - they don't have a `call` method.
 
@@ -632,7 +682,7 @@ Resource templates only use the `define` method to configure their properties -
 |--------|---------|-------------|
 | `define` | Class definition | Block for defining resource template metadata and URI template |
 
-#### Examples
+### Examples
 
 This is an example resource template that provides a completion for a parameter of the URI template:
 
@@ -668,13 +718,15 @@ class TestResourceTemplate < ModelContextProtocol::Server::ResourceTemplate
 end
 ```
 
-### Tools
+---
+
+## Tools
 
 The `ModelContextProtocol::Server::Tool` base class allows subclasses to define a tool that the MCP client can use.
 
 Define the tool properties and schemas, then implement the `call` method to build your tool response. Arguments from the MCP client and server context are available, along with logging capabilities.
 
-#### Tool Definition
+### Tool Definition
 
 Use the `define` block to set [tool properties](https://spec.modelcontextprotocol.io/specification/2025-06-18/server/tools/) and configure schemas.
 
@@ -686,7 +738,7 @@ Use the `define` block to set [tool properties](https://spec.modelcontextprotoco
 | `input_schema` | JSON schema block for validating tool inputs |
 | `output_schema` | JSON schema block for validating structured content outputs |
 
-#### Tool Methods
+### Tool Methods
 
 Define your tool properties and schemas, implement the `call` method using content helpers and `respond_with` to serialize responses. You can wrap long running operations in a `cancellable` block to allow clients to cancel the request. Also, you can automatically send progress notifications to clients by wrapping long-running operations in a `progressable` block.
 
@@ -698,7 +750,7 @@ Define your tool properties and schemas, implement the `call` method using conte
 | `progressable` | Within `call` | Wrap long-running operations to send clients progress notifications (e.g., `progressable { slow_operation }`) |
 | `respond_with` | Within `call` | Return properly formatted response data with various content types |
 
-#### Content Blocks
+### Content Blocks
 
 Use content blocks to properly format the content included in tool responses.
 
@@ -710,7 +762,7 @@ Use content blocks to properly format the content included in tool responses.
 | `embedded_resource_content` | Within `call` | Create embedded resource content block (requires `resource:`) |
 | `resource_link` | Within `call` | Create resource link content block (requires `name:` and `uri:`) |
 
-#### Response Types
+### Response Types
 
 Tools can return different types of responses using `respond_with`.
 
@@ -721,7 +773,7 @@ Tools can return different types of responses using `respond_with`.
 | `content:` | `respond_with content: [content_blocks]` | Return array of mixed content blocks |
 | `error:` | `respond_with error: "message"` | Return tool error response |
 
-#### Available Instance Variables
+### Available Instance Variables
 
 Arguments from MCP clients and server context are available, along with logging capabilities.
 
@@ -731,7 +783,7 @@ Arguments from MCP clients and server context are available, along with logging
 | `context` | Within `call` | Hash containing server configuration context values |
 | `logger` | Within `call` | Logger instance for logging (e.g., `logger.info("message")`) |
 
-#### Examples
+### Examples
 
 This is an example of a tool that returns structured content validated by an output schema:
 
@@ -1096,13 +1148,15 @@ class TestToolWithProgressableAndCancellable < ModelContextProtocol::Server::Too
 end
 ```
 
-### Completions
+---
+
+## Completions
 
 The `ModelContextProtocol::Server::Completion` base class allows subclasses to define a completion that the MCP client can use to obtain hints or suggestions for arguments to prompts and resources.
 
 Implement the `call` method to build your completion logic using the provided argument name and value. Completions are simpler than other server features - they don't use a `define` block and only provide filtered suggestion lists.
 
-#### Completion Methods
+### Completion Methods
 
 Completions only implement the `call` method to provide completion logic.
 
@@ -1111,7 +1165,7 @@ Completions only implement the `call` method to provide completion logic.
 | `call` | Instance method | Main method to implement completion logic and build response |
 | `respond_with` | Within `call` | Return properly formatted completion response (e.g., `respond_with values:`) |
 
-#### Available Instance Variables
+### Available Instance Variables
 
 Completions receive the argument name and current value being completed.
 
@@ -1120,7 +1174,7 @@ Completions receive the argument name and current value being completed.
 | `argument_name` | Within `call` | String name of the argument being completed |
 | `argument_value` | Within `call` | Current partial value being typed by the user |
 
-#### Examples
+### Examples
 
 This is an example completion that returns an array of values in the response:
 
@@ -1137,25 +1191,7 @@ class TestCompletion < ModelContextProtocol::Server::Completion
 end
 ```
 
-## Installation
-
-Add this line to your application's Gemfile:
-
-```ruby
-gem 'model-context-protocol-rb'
-```
-
-And then execute:
-
-```bash
-bundle
-```
-
-Or install it yourself as:
-
-```bash
-gem install model-context-protocol-rb
-```
+---
 
 ## Development
 

data/lib/model_context_protocol/server/streamable_http_transport.rb

@@ -182,7 +182,13 @@ module ModelContextProtocol
             event_id = next_event_id
             send_sse_event(stream, {}, event_id)
           end
+
+          # Close stream immediately when work is complete
+          close_stream(temp_stream_id, reason: "request_completed")
+        rescue IOError, Errno::EPIPE, Errno::ECONNRESET
+          # Client disconnected during processing
         ensure
+          # Fallback cleanup
           @stream_registry.unregister_stream(temp_stream_id)
         end
       end
@@ -201,6 +207,20 @@ module ModelContextProtocol
       stream.flush if stream.respond_to?(:flush)
     end
 
+    def close_stream(session_id, reason: "completed")
+      if (stream = @stream_registry.get_local_stream(session_id))
+        begin
+          send_sse_event(stream, {type: "stream_complete", reason: reason})
+          stream.close
+        rescue IOError, Errno::EPIPE, Errno::ECONNRESET, Errno::ENOTCONN, Errno::EBADF
+          nil
+        end
+
+        @stream_registry.unregister_stream(session_id)
+        @session_store.mark_stream_inactive(session_id) if @require_sessions
+      end
+    end
+
     def handle_post_request(env)
       validation_error = validate_headers(env)
       return validation_error if validation_error
@@ -404,7 +424,7 @@ module ModelContextProtocol
         stream.write(": ping\n\n")
         stream.flush if stream.respond_to?(:flush)
         true
-      rescue IOError, Errno::EPIPE, Errno::ECONNRESET
+      rescue IOError, Errno::EPIPE, Errno::ECONNRESET, Errno::ENOTCONN, Errno::EBADF
         false
       end
     end
@@ -438,12 +458,10 @@ module ModelContextProtocol
           send_ping_to_stream(stream)
           @stream_registry.refresh_heartbeat(session_id)
         else
-          @stream_registry.unregister_stream(session_id)
-          @session_store.mark_stream_inactive(session_id)
+          close_stream(session_id, reason: "client_disconnected")
         end
-      rescue IOError, Errno::EPIPE, Errno::ECONNRESET
-        @stream_registry.unregister_stream(session_id)
-        @session_store.mark_stream_inactive(session_id)
+      rescue IOError, Errno::EPIPE, Errno::ECONNRESET, Errno::ENOTCONN, Errno::EBADF
+        close_stream(session_id, reason: "network_error")
       end
     end
 
@@ -468,7 +486,7 @@ module ModelContextProtocol
           send_to_stream(stream, data)
           return true
         rescue IOError, Errno::EPIPE, Errno::ECONNRESET
-          @stream_registry.unregister_stream(session_id)
+          close_stream(session_id, reason: "client_disconnected")
         end
       end
 
@@ -493,7 +511,7 @@ module ModelContextProtocol
       @stream_registry.get_all_local_streams.each do |session_id, stream|
         send_to_stream(stream, notification)
       rescue IOError, Errno::EPIPE, Errno::ECONNRESET
-        @stream_registry.unregister_stream(session_id)
+        close_stream(session_id, reason: "client_disconnected")
       end
     end
 

data/lib/model_context_protocol/version.rb

@@ -1,3 +1,3 @@
 module ModelContextProtocol
-  VERSION = "0.5.0"
+  VERSION = "0.5.1"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: model-context-protocol-rb
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.5.1
 platform: ruby
 authors:
 - Dick Davis