Class ::nsmcp::Protocol (public)

 ::nx::Class ::nsmcp::Protocol

Defined in /usr/local/ns/tcl/nsmcp/protocol.tcl

Testcases:

No testcase defined.

Source code:

    :property registry:required
    :property authorizer:required
    :property {versions {2025-03-26 2025-06-18 2025-11-25}}

    :public method supports {version} {
        #
        # Check whether an MCP protocol version is supported.
        #
        # Compare the requested version with the configured version list.
        #
        # @param version Requested MCP protocol-version string.
        #
        # @return True for a supported version, otherwise false.
        #

        return [expr {$version in ${:versions}}]
    }

    :method parameter {object key types} {
        # Protocol validation, not a JSON implementation. Native access preserves
        # JSON types; getvalue -output triples returns the selected member's data.
        if {[catch {
            ns_json triples gettype -path [list $key] -- $object
        } type] || $type ni $types} {
            return -code error -errorcode {NSMCP RPC -32602} "Missing or invalid parameter: $key"
        }
        return [ns_json triples getvalue -output triples -path [list $key] -- $object]
    }

    :method uniqueMembers {value} {
        lassign $value name type members
        if {$type ni {object array}} {
            return
        }
        set seen {}
        foreach {name type data} $members {
            if {[dict exists $seen $name]} {
                error "duplicate JSON member"
            }
            dict set seen $name 1
            :uniqueMembers [list {} $type $data]
        }
    }

    :public method error {id code message} {
        #
        # Encode a JSON-RPC error response.
        #
        # Preserve the typed request identifier while constructing the standard
        # error envelope.
        #
        # @param id Typed request or retained evidence identifier.
        # @param code JSON-RPC error code.
        # @param message Diagnostic message text.
        #
        # @return Serialized JSON for the error response.
        #

        return [ns_json value -- [list {} object [list jsonrpc string 2.0  id [lindex $id 1] [lindex $id 2]  error object [list code number $code message string $message]]]]
    }

    :public method dispatch {context method params} {
        #
        # Dispatch an authenticated MCP protocol method.
        #
        # Handle initialization and tool operations using the configured registry
        # and request authorizer.
        #
        # @param context Authenticated request context carrying the principal,
        #        grants and selected server.
        # @param method MCP protocol method or HTTP method, depending on the
        #        adapter.
        # @param params Rooted typed JSON-RPC parameters.
        #
        # @return The rooted JSON protocol result or notification result.
        #

        switch -- $method {
            initialize {
                set requested [:parameter $params protocolVersion string]
                :parameter $params capabilities object
                set client [list {} object [:parameter $params clientInfo object]]
                :parameter $client name string
                :parameter $client version string
                set version [expr {[:supports $requested] ? $requested : [lindex ${:versions} end]}]
                return [list {} object [list protocolVersion string $version  capabilities object {tools object {listChanged boolean false}}  serverInfo object {name string nsmcp version string 0.1}]]
            }
            ping {
                return {{} object {}}
            }
            tools/list {
                if {![catch {
                    ns_json triples gettype -path cursor -- $params
                }]} {
                    return -code error -errorcode {NSMCP RPC -32602} "Pagination is not available"
                }
                return [${:registry} list $context ${:authorizer}]
            }
            tools/call {
                set name [:parameter $params name string]
                set arguments {{} object {}}
                if {![catch {
                    ns_json triples gettype -path arguments -- $params
                }]} {
                    set arguments [list {} object [:parameter $params arguments object]]
                }
                return [${:registry} call $context ${:authorizer} $name $arguments]
            }
            default {
                return -code error -errorcode {NSMCP RPC -32601} "Method not found"
            }
        }
    }

    :public method handle {context body} {
        #
        # Parse and handle one JSON-RPC request body.
        #
        # Enforce JSON structure and size bounds, then encode protocol errors or
        # dispatch results.
        #
        # @param context Authenticated request context carrying the principal,
        #        grants and selected server.
        # @param body Serialized HTTP or JSON-RPC request body.
        #
        # @return The serialized protocol response.
        #

        set null {{} null {}}
        if {[catch {
            ns_json parse -maxdepth 32 -maxstring 65536 -maxcontainer 256  -validatenumbers -output triples -- $body
        } request]} {
            return [dict create status 400 body [:error $null -32700 "Parse error"]]
        }
        set id $null
        set hasId 0
        if {[catch {
            :uniqueMembers $request
            if {[lindex $request 1] ne "object"} {
                error "expected object"
            }
            set hasId [expr {![catch {
                ns_json triples gettype -path id -- $request
            } idType]}]
            if {$hasId} {
                set id [list {} $idType [:parameter $request id {string number}]]
            }
            if {[:parameter $request jsonrpc string] ne "2.0"} {
                error "invalid JSON-RPC version"
            }
            set method [:parameter $request method string]
            set params {{} object {}}
            if {![catch {
                ns_json triples gettype -path params -- $request
            }]} {
                set params [list {} object [:parameter $request params object]]
            }
        }]} {
            return [dict create status 400 body [:error $null -32600 "Invalid request"]]
        }
        if {!$hasId} {
            # Notifications cannot invoke tools. No asynchronous work is supported.
            return [dict create status 202 body {}]
        }
        if {[catch {
            :dispatch $context $method $params
        } result options]} {
            set code -32603
            set message "Internal error"
            set ec [dict get $options -errorcode]
            if {[lrange $ec 0 1] eq {NSMCP RPC}} {
                set code [lindex $ec 2]
                set message $result
            }
            return [dict create status 200 body [:error $id $code $message]]
        }
        return [dict create status 200 body [ns_json value -- [list {} object  [list jsonrpc string 2.0 id [lindex $id 1] [lindex $id 2]  result object [lindex $result 2]]]]]
    }

XQL Not present:

Generic, PostgreSQL, Oracle