nsmcp::ToolRegistry method refreshProviders (public)

 <instance of nsmcp::ToolRegistry> refreshProviders

Defined in /usr/local/ns/tcl/nsmcp/01-tools.tcl

Testcases:

No testcase defined.

Source code:

if {${:providerContext} eq ""} {return}
set descriptors {}
catch {set descriptors [nsv_array get nsmcp:providers]}
# Registration is trusted startup Tcl, never an MCP/client operation.
dict for {provider descriptor} $descriptors {
    if {[dict exists ${:providers} $provider]} {continue}
    foreach field {file factory} {
        if {![dict exists $descriptor $field]} {error "provider $provider lacks $field"}
    }
    if {[dict exists $descriptor requires]
        && [info commands [dict get $descriptor requires]] eq ""} {continue}
    set context ${:providerContext}
    if {[dict exists $descriptor section]} {
        dict set context fallbackSection [dict get $context section]
        dict set context section [dict get $descriptor section]
    }
    if {[dict exists $descriptor fallbackParameters]} {
        dict set context fallbackParameters [dict get $descriptor fallbackParameters]
    }
    if {[dict exists $descriptor enabledParameter]} {
        set parameter [dict get $descriptor enabledParameter]
        set enabled [::nsmcp::ToolRegistry providerConfig $context $parameter false]
        if {![string is boolean -strict $enabled]} {
            error "provider $provider requires a boolean $parameter"
        }
        if {!$enabled} {continue}
    }
    set file [dict get $descriptor file]
    if {[file pathtype $file] ne "absolute" || ![file isfile $file]} {
        error "provider $provider must provide an absolute readable Tcl file"
    }
    uplevel #0 [list source $file]
    set factory [dict get $descriptor factory]
    if {[llength $factory] != 1 || [info commands $factory] eq ""} {
        error "provider $provider must provide a factory command"
    }
    # Validate the entire batch before adding any tool. Factory failures
    # must not leave a partially registered provider or replace a tool.
    set candidates [$factory $context]
    set pending {}
    foreach tool $candidates {
        if {![nsf::object::exists $tool] || ![$tool info has type ::nsmcp::Tool]} {
            error "provider $provider returned a non-Tool object"
        }
        set name [$tool name]
        if {[dict exists ${:tools} $name] || [dict exists $pending $name]} {
            error "duplicate tool: $name"
        }
        dict set pending $name $tool
    }
    dict for {name tool} $pending {dict set :tools $name $tool}
    dict set :providers $provider [dict keys $pending]
}
return ${:providers}

XQL Not present:

Generic, PostgreSQL, Oracle