nimgent/mcp

This page is generated from the module’s exported API and ## documentation comments.

MCP 2026-07-28 client over stdio and Streamable HTTP.

The client deliberately pins the modern stateless revision. It discovers tools, resources, prompts, completions, subscriptions, and task handles, then adapts remote tools to nimgent’s normal Tool type.

Constants

mcpProtocolVersion

MCP revision used by the client.

mcpProtocolVersion = "2026-07-28"

View source

Types

McpRequestOptions

Optional request metadata sent in the MCP _meta object.

McpRequestOptions = object
  progressToken*: JsonNode
  logLevel*: string
  traceContext*: JsonNode
  metadata*: JsonNode

View source

McpInputRequest

One input request from an input_required result.

McpInputRequest = object
  key*: string
  methodName*: string
  params*: JsonNode
  raw*: JsonNode

View source

McpInputHandler

McpInputHandler = proc (request: McpInputRequest): JsonNode {.closure.}

View source

McpProgressHandler

McpProgressHandler = proc (progress, total: float; message: string) {.closure.}

View source

McpNotificationHandler

McpNotificationHandler = proc (methodName: string; params: JsonNode) {.closure.}

View source

McpClientError

Error returned by an MCP client operation.

McpClientError = object of CatchableError
  code*: int
  data*: JsonNode

View source

McpToolInfo

Discovered MCP tool metadata.

McpToolInfo = object
  name*: string
  description*: string
  inputSchema*: JsonNode
  outputSchema*: JsonNode
  title*: string
  icons*: JsonNode
  annotations*: JsonNode

View source

McpResourceInfo

Discovered MCP resource metadata.

McpResourceInfo = object
  uri*: string
  uriTemplate*: string
  name*: string
  title*: string
  description*: string
  icons*: JsonNode
  mimeType*: string
  size*: int64
  annotations*: JsonNode

View source

McpResourceContent

Text or base64-encoded binary resource content.

McpResourceContent = object
  uri*: string
  mimeType*: string
  text*: string
  blob*: string
  isBlob*: bool
  raw*: JsonNode

View source

McpResourceReadResult

McpResourceReadResult = object
  resultType*: string
  contents*: seq[McpResourceContent]
  ttlMs*: int64
  cacheScope*: string
  inputRequests*: JsonNode
  requestState*: string
  raw*: JsonNode

View source

McpPromptArgumentInfo

McpPromptArgumentInfo = object
  name*: string
  description*: string
  required*: bool

View source

McpPromptInfo

Discovered MCP prompt metadata.

McpPromptInfo = object
  name*: string
  title*: string
  description*: string
  icons*: JsonNode
  arguments*: seq[McpPromptArgumentInfo]

View source

McpPromptMessage

McpPromptMessage = object
  role*: string
  content*: JsonNode
  raw*: JsonNode

View source

McpPromptResult

McpPromptResult = object
  resultType*: string
  description*: string
  messages*: seq[McpPromptMessage]
  inputRequests*: JsonNode
  requestState*: string
  raw*: JsonNode

View source

McpCompletionResult

McpCompletionResult = object
  values*: seq[string]
  total*: int
  hasMore*: bool
  raw*: JsonNode

View source

McpTaskInfo

Task handle and current state returned by the Tasks extension.

McpTaskInfo = object
  taskId*: string
  status*: string
  statusMessage*: string
  createdAt*: string
  lastUpdatedAt*: string
  ttlMs*: int64
  pollIntervalMs*: int
  progress*: float
  hasProgress*: bool
  total*: float
  hasTotal*: bool
  inputRequests*: JsonNode
  result*: JsonNode
  error*: JsonNode
  raw*: JsonNode

View source

McpCallResult

Content and status returned by an MCP tool call.

McpCallResult = object
  content*: JsonNode
  structuredContent*: JsonNode
  isError*: bool
  resultType*: string
  inputRequests*: JsonNode
  requestState*: string
  task*: McpTaskInfo
  raw*: JsonNode

View source

McpSubscriptionFilter

Change streams requested from subscriptions/listen.

McpSubscriptionFilter = object
  toolsListChanged*: bool
  promptsListChanged*: bool
  resourcesListChanged*: bool
  resourceSubscriptions*: seq[string]

View source

McpSubscription

A live MCP subscription backed by a pull-based event stream.

McpSubscription = ref object
  id*: int
  filter*: McpSubscriptionFilter
  queue*: FutureStream[JsonNode]
  acknowledged*: Future[JsonNode]
  closed*: Future[void]

View source

McpSubscriptionMessageHandler

McpSubscriptionMessageHandler = proc (message: JsonNode) {.closure.}

View source

McpClient

Client connected to an MCP server over stdio or Streamable HTTP.

McpClient = ref object
  progressHandler*: McpProgressHandler
  notificationHandler*: McpNotificationHandler
  serverInfo*: JsonNode
  discovery*: JsonNode

View source

Procedures

close (overload 1)

Close the MCP process and pending requests.

proc close(client: McpClient) {.raises: [ValueError, Exception],
                                tags: [RootEffect, WriteIOEffect], forbids: [].}

Arguments

Name	Type	Default
client	McpClient

View source

requestAsync

Send a raw MCP request and return its complete result object.

proc requestAsync(client: McpClient; methodName: string; params: JsonNode = nil;
                  options = McpRequestOptions()): Future[JsonNode] {.
    stackTrace: false, raises: [Exception, ValueError, McpClientError, KeyError,
                                LibraryError, SslError, IOError], tags: [
    RootEffect, ReadDirEffect, ReadEnvEffect, TimeEffect, ReadIOEffect,
    WriteIOEffect], forbids: [].}

Returns: Future[JsonNode].

Arguments

Name	Type	Default
client	McpClient
methodName	string
params	JsonNode	nil
options	inferred	McpRequestOptions()

View source

notifyAsync

Send an MCP notification without waiting for a response.

proc notifyAsync(client: McpClient; methodName: string; params: JsonNode = nil;
                 options = McpRequestOptions()): Future[void] {.
    stackTrace: false, raises: [Exception, McpClientError, KeyError,
                                LibraryError, SslError, IOError, ValueError],
    tags: [RootEffect, ReadDirEffect, ReadEnvEffect, TimeEffect, ReadIOEffect],
    forbids: [].}

Returns: Future[void].

Arguments

Name	Type	Default
client	McpClient
methodName	string
params	JsonNode	nil
options	inferred	McpRequestOptions()

View source

notify

proc notify(client: McpClient; methodName: string; params: JsonNode = nil;
            options = McpRequestOptions()) {.raises: [ValueError, Exception,
    OSError, McpClientError, KeyError, LibraryError, SslError, IOError],
    tags: [TimeEffect, RootEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect],
    forbids: [].}

Arguments

Name	Type	Default
client	McpClient
methodName	string
params	JsonNode	nil
options	inferred	McpRequestOptions()

View source

setClientCapabilities

proc setClientCapabilities(client: McpClient; capabilities: JsonNode) {.
    raises: [McpClientError], tags: [], forbids: [].}

Arguments

Name	Type	Default
client	McpClient
capabilities	JsonNode

View source

setInputHandler

proc setInputHandler(client: McpClient; methodName: string;
                     handler: McpInputHandler) {.raises: [McpClientError],
    tags: [], forbids: [].}

Arguments

Name	Type	Default
client	McpClient
methodName	string
handler	McpInputHandler

View source

setElicitationHandler

proc setElicitationHandler(client: McpClient; handler: McpInputHandler) {.
    raises: [McpClientError], tags: [], forbids: [].}

Arguments

Name	Type	Default
client	McpClient
handler	McpInputHandler

View source

setSamplingHandler

proc setSamplingHandler(client: McpClient; handler: McpInputHandler) {.
    raises: [McpClientError], tags: [], forbids: [].}

Arguments

Name	Type	Default
client	McpClient
handler	McpInputHandler

View source

setRootsHandler

proc setRootsHandler(client: McpClient; handler: McpInputHandler) {.
    raises: [McpClientError], tags: [], forbids: [].}

Arguments

Name	Type	Default
client	McpClient
handler	McpInputHandler

View source

setNotificationHandler

proc setNotificationHandler(client: McpClient; handler: McpNotificationHandler) {.
    raises: [McpClientError], tags: [], forbids: [].}

Arguments

Name	Type	Default
client	McpClient
handler	McpNotificationHandler

View source

setProgressHandler

proc setProgressHandler(client: McpClient; handler: McpProgressHandler) {.
    raises: [McpClientError], tags: [], forbids: [].}

Arguments

Name	Type	Default
client	McpClient
handler	McpProgressHandler

View source

discoverAsync

Discover and validate the MCP server protocol and metadata.

proc discoverAsync(client: McpClient; options = McpRequestOptions()): Future[
    JsonNode] {.stackTrace: false, raises: [Exception, ValueError,
    McpClientError, KeyError, LibraryError, SslError, IOError], tags: [
    RootEffect, ReadDirEffect, ReadEnvEffect, TimeEffect, ReadIOEffect,
    WriteIOEffect], forbids: [].}

Returns: Future[JsonNode].

Arguments

Name	Type	Default
client	McpClient
options	inferred	McpRequestOptions()

View source

pingAsync

Check that the connected MCP server is responsive.

proc pingAsync(client: McpClient; options = McpRequestOptions()): Future[
    JsonNode] {.stackTrace: false, raises: [Exception, ValueError,
    McpClientError, KeyError, LibraryError, SslError, IOError], tags: [
    RootEffect, ReadDirEffect, ReadEnvEffect, TimeEffect, ReadIOEffect,
    WriteIOEffect], forbids: [].}

Returns: Future[JsonNode].

Arguments

Name	Type	Default
client	McpClient
options	inferred	McpRequestOptions()

View source

ping

proc ping(client: McpClient; options = McpRequestOptions()): JsonNode {.raises: [
    ValueError, Exception, OSError, McpClientError, KeyError, LibraryError,
    SslError, IOError], tags: [TimeEffect, RootEffect, ReadDirEffect,
                               ReadEnvEffect, ReadIOEffect, WriteIOEffect],
    forbids: [].}

Returns: JsonNode.

Arguments

Name	Type	Default
client	McpClient
options	inferred	McpRequestOptions()

View source

connectMcpHttpAsync

Connect to a stateless MCP Streamable HTTP endpoint.

proc connectMcpHttpAsync(endpoint: string; bearerToken = "";
                         headers: HttpHeaders = nil; clientName = "nimgent";
                         clientVersion = "0.1.0";
                         clientCapabilities: JsonNode = nil): Future[McpClient] {.
    stackTrace: false,
    raises: [Exception, ValueError, McpClientError, KeyError, CatchableError], tags: [
    RootEffect, ReadDirEffect, ReadEnvEffect, TimeEffect, ReadIOEffect,
    WriteIOEffect], forbids: [].}

Returns: Future[McpClient].

Arguments

Name	Type	Default
endpoint	string
bearerToken	inferred	""
headers	HttpHeaders	nil
clientName	inferred	"nimgent"
clientVersion	inferred	"0.1.0"
clientCapabilities	JsonNode	nil

View source

connectMcpHttp

proc connectMcpHttp(endpoint: string; bearerToken = "";
                    headers: HttpHeaders = nil; clientName = "nimgent";
                    clientVersion = "0.1.0"; clientCapabilities: JsonNode = nil): McpClient {.raises: [
    ValueError, Exception, OSError, McpClientError, KeyError, CatchableError], tags: [
    TimeEffect, RootEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect,
    WriteIOEffect], forbids: [].}

Returns: McpClient.

Arguments

Name	Type	Default
endpoint	string
bearerToken	inferred	""
headers	HttpHeaders	nil
clientName	inferred	"nimgent"
clientVersion	inferred	"0.1.0"
clientCapabilities	JsonNode	nil

View source

connectMcpStreamableHttpAsync

Alias with the transport name used by MCP documentation.

proc connectMcpStreamableHttpAsync(endpoint: string; bearerToken = "";
                                   headers: HttpHeaders = nil;
                                   clientName = "nimgent";
                                   clientVersion = "0.1.0";
                                   clientCapabilities: JsonNode = nil): Future[
    McpClient] {.stackTrace: false, raises: [Exception, ValueError,
    McpClientError, KeyError, CatchableError], tags: [RootEffect, ReadDirEffect,
    ReadEnvEffect, TimeEffect, ReadIOEffect, WriteIOEffect], forbids: [].}

Returns: Future[McpClient].

Arguments

Name	Type	Default
endpoint	string
bearerToken	inferred	""
headers	HttpHeaders	nil
clientName	inferred	"nimgent"
clientVersion	inferred	"0.1.0"
clientCapabilities	JsonNode	nil

View source

connectMcpStreamableHttp

proc connectMcpStreamableHttp(endpoint: string; bearerToken = "";
                              headers: HttpHeaders = nil;
                              clientName = "nimgent"; clientVersion = "0.1.0";
                              clientCapabilities: JsonNode = nil): McpClient {.raises: [
    ValueError, Exception, OSError, McpClientError, KeyError, CatchableError], tags: [
    TimeEffect, RootEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect,
    WriteIOEffect], forbids: [].}

Returns: McpClient.

Arguments

Name	Type	Default
endpoint	string
bearerToken	inferred	""
headers	HttpHeaders	nil
clientName	inferred	"nimgent"
clientVersion	inferred	"0.1.0"
clientCapabilities	JsonNode	nil

View source

connectMcpStdioAsync

Start an MCP server process and connect to it over stdio.

proc connectMcpStdioAsync(command: seq[string]; workingDir = "";
                          env: StringTableRef = nil; clientName = "nimgent";
                          clientVersion = "0.1.0";
                          clientCapabilities: JsonNode = nil): Future[McpClient] {.
    stackTrace: false, raises: [Exception, ValueError, McpClientError, OSError,
                                IOError, CatchableError], tags: [RootEffect,
    ExecIOEffect, ReadEnvEffect, ReadIOEffect, WriteIOEffect, ReadDirEffect,
    TimeEffect], forbids: [].}

Returns: Future[McpClient].

Arguments

Name	Type	Default
command	seq[string]
workingDir	inferred	""
env	StringTableRef	nil
clientName	inferred	"nimgent"
clientVersion	inferred	"0.1.0"
clientCapabilities	JsonNode	nil

View source

connectMcpStdio

Synchronously start and connect to an MCP server over stdio.

proc connectMcpStdio(command: seq[string]; workingDir = "";
                     env: StringTableRef = nil; clientName = "nimgent";
                     clientVersion = "0.1.0"; clientCapabilities: JsonNode = nil): McpClient {.raises: [
    ValueError, Exception, OSError, McpClientError, IOError, CatchableError], tags: [
    TimeEffect, RootEffect, ExecIOEffect, ReadEnvEffect, ReadIOEffect,
    WriteIOEffect, ReadDirEffect], forbids: [].}

Returns: McpClient.

Arguments

Name	Type	Default
command	seq[string]
workingDir	inferred	""
env	StringTableRef	nil
clientName	inferred	"nimgent"
clientVersion	inferred	"0.1.0"
clientCapabilities	JsonNode	nil

View source

listToolsAsync

Discover the tools exposed by the connected MCP server.

proc listToolsAsync(client: McpClient; options = McpRequestOptions()): Future[
    seq[McpToolInfo]] {.stackTrace: false, raises: [Exception, ValueError,
    McpClientError, KeyError, LibraryError, SslError, IOError], tags: [
    RootEffect, ReadDirEffect, ReadEnvEffect, TimeEffect, ReadIOEffect,
    WriteIOEffect], forbids: [].}

Returns: Future[seq[McpToolInfo]].

Arguments

Name	Type	Default
client	McpClient
options	inferred	McpRequestOptions()

View source

listTools

Synchronously discover the connected server’s tools.

proc listTools(client: McpClient; options = McpRequestOptions()): seq[
    McpToolInfo] {.raises: [ValueError, Exception, OSError, McpClientError,
                            KeyError, LibraryError, SslError, IOError], tags: [
    TimeEffect, RootEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect,
    WriteIOEffect], forbids: [].}

Returns: seq[McpToolInfo].

Arguments

Name	Type	Default
client	McpClient
options	inferred	McpRequestOptions()

View source

listResourcesAsync

Discover all static MCP resources, following pagination cursors.

proc listResourcesAsync(client: McpClient; options = McpRequestOptions()): Future[
    seq[McpResourceInfo]] {.stackTrace: false, raises: [Exception, ValueError,
    McpClientError, KeyError, LibraryError, SslError, IOError], tags: [
    RootEffect, ReadDirEffect, ReadEnvEffect, TimeEffect, ReadIOEffect,
    WriteIOEffect], forbids: [].}

Returns: Future[seq[McpResourceInfo]].

Arguments

Name	Type	Default
client	McpClient
options	inferred	McpRequestOptions()

View source

listResources

proc listResources(client: McpClient; options = McpRequestOptions()): seq[
    McpResourceInfo] {.raises: [ValueError, Exception, OSError, McpClientError,
                                KeyError, LibraryError, SslError, IOError], tags: [
    TimeEffect, RootEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect,
    WriteIOEffect], forbids: [].}

Returns: seq[McpResourceInfo].

Arguments

Name	Type	Default
client	McpClient
options	inferred	McpRequestOptions()

View source

listResourceTemplatesAsync

Discover all URI-template resources, following pagination cursors.

proc listResourceTemplatesAsync(client: McpClient; options = McpRequestOptions()): Future[
    seq[McpResourceInfo]] {.stackTrace: false, raises: [Exception, ValueError,
    McpClientError, KeyError, LibraryError, SslError, IOError], tags: [
    RootEffect, ReadDirEffect, ReadEnvEffect, TimeEffect, ReadIOEffect,
    WriteIOEffect], forbids: [].}

Returns: Future[seq[McpResourceInfo]].

Arguments

Name	Type	Default
client	McpClient
options	inferred	McpRequestOptions()

View source

listResourceTemplates

proc listResourceTemplates(client: McpClient; options = McpRequestOptions()): seq[
    McpResourceInfo] {.raises: [ValueError, Exception, OSError, McpClientError,
                                KeyError, LibraryError, SslError, IOError], tags: [
    TimeEffect, RootEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect,
    WriteIOEffect], forbids: [].}

Returns: seq[McpResourceInfo].

Arguments

Name	Type	Default
client	McpClient
options	inferred	McpRequestOptions()

View source

listPromptsAsync

Discover all MCP prompts, following pagination cursors.

proc listPromptsAsync(client: McpClient; options = McpRequestOptions()): Future[
    seq[McpPromptInfo]] {.stackTrace: false, raises: [Exception, ValueError,
    McpClientError, KeyError, LibraryError, SslError, IOError], tags: [
    RootEffect, ReadDirEffect, ReadEnvEffect, TimeEffect, ReadIOEffect,
    WriteIOEffect], forbids: [].}

Returns: Future[seq[McpPromptInfo]].

Arguments

Name	Type	Default
client	McpClient
options	inferred	McpRequestOptions()

View source

listPrompts

proc listPrompts(client: McpClient; options = McpRequestOptions()): seq[
    McpPromptInfo] {.raises: [ValueError, Exception, OSError, McpClientError,
                              KeyError, LibraryError, SslError, IOError], tags: [
    TimeEffect, RootEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect,
    WriteIOEffect], forbids: [].}

Returns: seq[McpPromptInfo].

Arguments

Name	Type	Default
client	McpClient
options	inferred	McpRequestOptions()

View source

requestWithInputAsync

Complete stateless input-required retries with the configured handlers.

proc requestWithInputAsync(client: McpClient; methodName: string;
                           params: JsonNode = nil;
                           options = McpRequestOptions(); maxInputRounds = 8): Future[
    JsonNode] {.stackTrace: false, raises: [Exception, ValueError,
    McpClientError, KeyError, LibraryError, SslError, IOError], tags: [
    RootEffect, ReadDirEffect, ReadEnvEffect, TimeEffect, ReadIOEffect,
    WriteIOEffect], forbids: [].}

Returns: Future[JsonNode].

Arguments

Name	Type	Default
client	McpClient
methodName	string
params	JsonNode	nil
options	inferred	McpRequestOptions()
maxInputRounds	inferred	8

View source

requestWithInput

proc requestWithInput(client: McpClient; methodName: string;
                      params: JsonNode = nil; options = McpRequestOptions();
                      maxInputRounds = 8): JsonNode {.raises: [ValueError,
    Exception, OSError, McpClientError, KeyError, LibraryError, SslError,
    IOError], tags: [TimeEffect, RootEffect, ReadDirEffect, ReadEnvEffect,
                     ReadIOEffect, WriteIOEffect], forbids: [].}

Returns: JsonNode.

Arguments

Name	Type	Default
client	McpClient
methodName	string
params	JsonNode	nil
options	inferred	McpRequestOptions()
maxInputRounds	inferred	8

View source

readResourceAsync

Read a static resource or URI-template instance.

proc readResourceAsync(client: McpClient; uri: string;
                       options = McpRequestOptions()): Future[
    McpResourceReadResult] {.stackTrace: false, raises: [Exception, ValueError,
    McpClientError, KeyError, LibraryError, SslError, IOError], tags: [
    RootEffect, ReadDirEffect, ReadEnvEffect, TimeEffect, ReadIOEffect,
    WriteIOEffect], forbids: [].}

Returns: Future[McpResourceReadResult].

Arguments

Name	Type	Default
client	McpClient
uri	string
options	inferred	McpRequestOptions()

View source

readResource

proc readResource(client: McpClient; uri: string; options = McpRequestOptions()): McpResourceReadResult {.raises: [
    ValueError, Exception, OSError, McpClientError, KeyError, LibraryError,
    SslError, IOError], tags: [TimeEffect, RootEffect, ReadDirEffect,
                               ReadEnvEffect, ReadIOEffect, WriteIOEffect],
    forbids: [].}

Returns: McpResourceReadResult.

Arguments

Name	Type	Default
client	McpClient
uri	string
options	inferred	McpRequestOptions()

View source

readResourceContentsAsync

proc readResourceContentsAsync(client: McpClient; uri: string;
                               options = McpRequestOptions()): Future[
    seq[McpResourceContent]] {.stackTrace: false, raises: [Exception,
    ValueError, McpClientError, KeyError, LibraryError, SslError, IOError], tags: [
    RootEffect, ReadDirEffect, ReadEnvEffect, TimeEffect, ReadIOEffect,
    WriteIOEffect], forbids: [].}

Returns: Future[seq[McpResourceContent]].

Arguments

Name	Type	Default
client	McpClient
uri	string
options	inferred	McpRequestOptions()

View source

readResourceContents

proc readResourceContents(client: McpClient; uri: string;
                          options = McpRequestOptions()): seq[McpResourceContent] {.raises: [
    ValueError, Exception, OSError, McpClientError, KeyError, LibraryError,
    SslError, IOError], tags: [TimeEffect, RootEffect, ReadDirEffect,
                               ReadEnvEffect, ReadIOEffect, WriteIOEffect],
    forbids: [].}

Returns: seq[McpResourceContent].

Arguments

Name	Type	Default
client	McpClient
uri	string
options	inferred	McpRequestOptions()

View source

getPromptAsync

Render a prompt with its string arguments.

proc getPromptAsync(client: McpClient; name: string; arguments: JsonNode = nil;
                    options = McpRequestOptions()): Future[McpPromptResult] {.
    stackTrace: false, raises: [Exception, ValueError, McpClientError, KeyError,
                                LibraryError, SslError, IOError], tags: [
    RootEffect, ReadDirEffect, ReadEnvEffect, TimeEffect, ReadIOEffect,
    WriteIOEffect], forbids: [].}

Returns: Future[McpPromptResult].

Arguments

Name	Type	Default
client	McpClient
name	string
arguments	JsonNode	nil
options	inferred	McpRequestOptions()

View source

getPrompt

proc getPrompt(client: McpClient; name: string; arguments: JsonNode = nil;
               options = McpRequestOptions()): McpPromptResult {.raises: [
    ValueError, Exception, OSError, McpClientError, KeyError, LibraryError,
    SslError, IOError], tags: [TimeEffect, RootEffect, ReadDirEffect,
                               ReadEnvEffect, ReadIOEffect, WriteIOEffect],
    forbids: [].}

Returns: McpPromptResult.

Arguments

Name	Type	Default
client	McpClient
name	string
arguments	JsonNode	nil
options	inferred	McpRequestOptions()

View source

completeAsync

Complete a prompt or resource-template argument.

proc completeAsync(client: McpClient; reference: JsonNode; argument: string;
                   prefix: string; contextArguments: JsonNode = nil;
                   options = McpRequestOptions()): Future[McpCompletionResult] {.
    stackTrace: false, raises: [Exception, ValueError, McpClientError, KeyError,
                                LibraryError, SslError, IOError], tags: [
    RootEffect, ReadDirEffect, ReadEnvEffect, TimeEffect, ReadIOEffect,
    WriteIOEffect], forbids: [].}

Returns: Future[McpCompletionResult].

Arguments

Name	Type	Default
client	McpClient
reference	JsonNode
argument	string
prefix	string
contextArguments	JsonNode	nil
options	inferred	McpRequestOptions()

View source

complete

proc complete(client: McpClient; reference: JsonNode; argument, prefix: string;
              contextArguments: JsonNode = nil; options = McpRequestOptions()): McpCompletionResult {.raises: [
    ValueError, Exception, OSError, McpClientError, KeyError, LibraryError,
    SslError, IOError], tags: [TimeEffect, RootEffect, ReadDirEffect,
                               ReadEnvEffect, ReadIOEffect, WriteIOEffect],
    forbids: [].}

Returns: McpCompletionResult.

Arguments

Name	Type	Default
client	McpClient
reference	JsonNode
argument	string
prefix	string
contextArguments	JsonNode	nil
options	inferred	McpRequestOptions()

View source

completePromptArgumentAsync

proc completePromptArgumentAsync(client: McpClient;
                                 prompt, argument, prefix: string;
                                 contextArguments: JsonNode = nil;
                                 options = McpRequestOptions()): Future[
    McpCompletionResult] {.stackTrace: false, raises: [Exception, ValueError,
    McpClientError, KeyError, LibraryError, SslError, IOError], tags: [
    RootEffect, ReadDirEffect, ReadEnvEffect, TimeEffect, ReadIOEffect,
    WriteIOEffect], forbids: [].}

Returns: Future[McpCompletionResult].

Arguments

Name	Type	Default
client	McpClient
prompt	string
argument	string
prefix	string
contextArguments	JsonNode	nil
options	inferred	McpRequestOptions()

View source

completeResourceArgumentAsync

proc completeResourceArgumentAsync(client: McpClient;
                                   uriTemplate, argument, prefix: string;
                                   contextArguments: JsonNode = nil;
                                   options = McpRequestOptions()): Future[
    McpCompletionResult] {.stackTrace: false, raises: [Exception, ValueError,
    McpClientError, KeyError, LibraryError, SslError, IOError], tags: [
    RootEffect, ReadDirEffect, ReadEnvEffect, TimeEffect, ReadIOEffect,
    WriteIOEffect], forbids: [].}

Returns: Future[McpCompletionResult].

Arguments

Name	Type	Default
client	McpClient
uriTemplate	string
argument	string
prefix	string
contextArguments	JsonNode	nil
options	inferred	McpRequestOptions()

View source

completePromptArgument

proc completePromptArgument(client: McpClient; prompt, argument, prefix: string;
                            contextArguments: JsonNode = nil;
                            options = McpRequestOptions()): McpCompletionResult {.raises: [
    ValueError, Exception, OSError, McpClientError, KeyError, LibraryError,
    SslError, IOError], tags: [TimeEffect, RootEffect, ReadDirEffect,
                               ReadEnvEffect, ReadIOEffect, WriteIOEffect],
    forbids: [].}

Returns: McpCompletionResult.

Arguments

Name	Type	Default
client	McpClient
prompt	string
argument	string
prefix	string
contextArguments	JsonNode	nil
options	inferred	McpRequestOptions()

View source

completeResourceArgument

proc completeResourceArgument(client: McpClient;
                              uriTemplate, argument, prefix: string;
                              contextArguments: JsonNode = nil;
                              options = McpRequestOptions()): McpCompletionResult {.raises: [
    ValueError, Exception, OSError, McpClientError, KeyError, LibraryError,
    SslError, IOError], tags: [TimeEffect, RootEffect, ReadDirEffect,
                               ReadEnvEffect, ReadIOEffect, WriteIOEffect],
    forbids: [].}

Returns: McpCompletionResult.

Arguments

Name	Type	Default
client	McpClient
uriTemplate	string
argument	string
prefix	string
contextArguments	JsonNode	nil
options	inferred	McpRequestOptions()

View source

callToolAsync

Call a remote MCP tool asynchronously.

proc callToolAsync(client: McpClient; name: string; arguments: JsonNode = nil;
                   options = McpRequestOptions()): Future[McpCallResult] {.
    stackTrace: false, raises: [Exception, ValueError, McpClientError, KeyError,
                                LibraryError, SslError, IOError], tags: [
    RootEffect, ReadDirEffect, ReadEnvEffect, TimeEffect, ReadIOEffect,
    WriteIOEffect], forbids: [].}

Returns: Future[McpCallResult].

Arguments

Name	Type	Default
client	McpClient
name	string
arguments	JsonNode	nil
options	inferred	McpRequestOptions()

View source

callTool

Synchronously call a remote MCP tool.

proc callTool(client: McpClient; name: string; arguments: JsonNode = nil;
              options = McpRequestOptions()): McpCallResult {.raises: [
    ValueError, Exception, OSError, McpClientError, KeyError, LibraryError,
    SslError, IOError], tags: [TimeEffect, RootEffect, ReadDirEffect,
                               ReadEnvEffect, ReadIOEffect, WriteIOEffect],
    forbids: [].}

Returns: McpCallResult.

Arguments

Name	Type	Default
client	McpClient
name	string
arguments	JsonNode	nil
options	inferred	McpRequestOptions()

View source

getTaskAsync

Read the current state of a task returned by a tool call.

proc getTaskAsync(client: McpClient; taskId: string;
                  options = McpRequestOptions()): Future[McpTaskInfo] {.
    stackTrace: false, raises: [Exception, ValueError, McpClientError, KeyError,
                                LibraryError, SslError, IOError], tags: [
    RootEffect, ReadDirEffect, ReadEnvEffect, TimeEffect, ReadIOEffect,
    WriteIOEffect], forbids: [].}

Returns: Future[McpTaskInfo].

Arguments

Name	Type	Default
client	McpClient
taskId	string
options	inferred	McpRequestOptions()

View source

getTask

proc getTask(client: McpClient; taskId: string; options = McpRequestOptions()): McpTaskInfo {.raises: [
    ValueError, Exception, OSError, McpClientError, KeyError, LibraryError,
    SslError, IOError], tags: [TimeEffect, RootEffect, ReadDirEffect,
                               ReadEnvEffect, ReadIOEffect, WriteIOEffect],
    forbids: [].}

Returns: McpTaskInfo.

Arguments

Name	Type	Default
client	McpClient
taskId	string
options	inferred	McpRequestOptions()

View source

updateTaskAsync

Supply responses for pending task input and resume the task.

proc updateTaskAsync(client: McpClient; taskId: string;
                     inputResponses: JsonNode; requestState = "";
                     options = McpRequestOptions()): Future[void] {.
    stackTrace: false, raises: [Exception, McpClientError, ValueError, KeyError,
                                LibraryError, SslError, IOError], tags: [
    RootEffect, ReadDirEffect, ReadEnvEffect, TimeEffect, ReadIOEffect,
    WriteIOEffect], forbids: [].}

Returns: Future[void].

Arguments

Name	Type	Default
client	McpClient
taskId	string
inputResponses	JsonNode
requestState	inferred	""
options	inferred	McpRequestOptions()

View source

updateTask

proc updateTask(client: McpClient; taskId: string; inputResponses: JsonNode;
                requestState = ""; options = McpRequestOptions()) {.raises: [
    ValueError, Exception, OSError, McpClientError, KeyError, LibraryError,
    SslError, IOError], tags: [TimeEffect, RootEffect, ReadDirEffect,
                               ReadEnvEffect, ReadIOEffect, WriteIOEffect],
    forbids: [].}

Arguments

Name	Type	Default
client	McpClient
taskId	string
inputResponses	JsonNode
requestState	inferred	""
options	inferred	McpRequestOptions()

View source

cancelTaskAsync

Cancel a running task.

proc cancelTaskAsync(client: McpClient; taskId: string;
                     options = McpRequestOptions()): Future[void] {.
    stackTrace: false, raises: [Exception, ValueError, McpClientError, KeyError,
                                LibraryError, SslError, IOError], tags: [
    RootEffect, ReadDirEffect, ReadEnvEffect, TimeEffect, ReadIOEffect,
    WriteIOEffect], forbids: [].}

Returns: Future[void].

Arguments

Name	Type	Default
client	McpClient
taskId	string
options	inferred	McpRequestOptions()

View source

cancelTask

proc cancelTask(client: McpClient; taskId: string; options = McpRequestOptions()) {.raises: [
    ValueError, Exception, OSError, McpClientError, KeyError, LibraryError,
    SslError, IOError], tags: [TimeEffect, RootEffect, ReadDirEffect,
                               ReadEnvEffect, ReadIOEffect, WriteIOEffect],
    forbids: [].}

Arguments

Name	Type	Default
client	McpClient
taskId	string
options	inferred	McpRequestOptions()

View source

cancelRequestAsync

Ask the server to cancel an in-flight request or subscription.

proc cancelRequestAsync(client: McpClient; requestId: int; reason = "";
                        options = McpRequestOptions()): Future[void] {.
    stackTrace: false, raises: [Exception, McpClientError, KeyError,
                                LibraryError, SslError, IOError, ValueError],
    tags: [RootEffect, ReadDirEffect, ReadEnvEffect, TimeEffect, ReadIOEffect],
    forbids: [].}

Returns: Future[void].

Arguments

Name	Type	Default
client	McpClient
requestId	int
reason	inferred	""
options	inferred	McpRequestOptions()

View source

cancelRequest

proc cancelRequest(client: McpClient; requestId: int; reason = "";
                   options = McpRequestOptions()) {.raises: [ValueError,
    Exception, OSError, McpClientError, KeyError, LibraryError, SslError,
    IOError],
    tags: [TimeEffect, RootEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect],
    forbids: [].}

Arguments

Name	Type	Default
client	McpClient
requestId	int
reason	inferred	""
options	inferred	McpRequestOptions()

View source

read

proc read(subscription: McpSubscription): Future[(bool, JsonNode)] {.
    raises: [McpClientError, ValueError, Exception], tags: [RootEffect],
    forbids: [].}

Returns: Future[(bool, JsonNode)].

Arguments

Name	Type	Default
subscription	McpSubscription

View source

waitAcknowledged

proc waitAcknowledged(subscription: McpSubscription): Future[JsonNode] {.
    raises: [McpClientError], tags: [], forbids: [].}

Returns: Future[JsonNode].

Arguments

Name	Type	Default
subscription	McpSubscription

View source

waitClosed

proc waitClosed(subscription: McpSubscription): Future[void] {.
    raises: [McpClientError], tags: [], forbids: [].}

Returns: Future[void].

Arguments

Name	Type	Default
subscription	McpSubscription

View source

isActive

proc isActive(subscription: McpSubscription): bool {.raises: [], tags: [],
    forbids: [].}

Returns: bool.

Arguments

Name	Type	Default
subscription	McpSubscription

View source

subscribeAsync (overload 1)

Open a live tools, prompts, or resources change stream.

proc subscribeAsync(client: McpClient; filter: McpSubscriptionFilter;
                    handler: McpSubscriptionMessageHandler = nil): Future[
    McpSubscription] {.stackTrace: false, raises: [Exception, ValueError,
    McpClientError, CatchableError], tags: [RootEffect, ReadDirEffect,
    ReadEnvEffect, TimeEffect, ReadIOEffect, WriteIOEffect], forbids: [].}

Returns: Future[McpSubscription].

Arguments

Name	Type	Default
client	McpClient
filter	McpSubscriptionFilter
handler	McpSubscriptionMessageHandler	nil

View source

subscribe (overload 1)

proc subscribe(client: McpClient; filter: McpSubscriptionFilter;
               handler: McpSubscriptionMessageHandler = nil): McpSubscription {.
    raises: [ValueError, Exception, OSError, McpClientError, CatchableError], tags: [
    TimeEffect, RootEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect,
    WriteIOEffect], forbids: [].}

Returns: McpSubscription.

Arguments

Name	Type	Default
client	McpClient
filter	McpSubscriptionFilter
handler	McpSubscriptionMessageHandler	nil

View source

subscribeAsync (overload 2)

proc subscribeAsync(client: McpClient; notifications: JsonNode;
                    handler: McpSubscriptionMessageHandler = nil): Future[
    McpSubscription] {.stackTrace: false, raises: [Exception, ValueError,
    McpClientError, CatchableError], tags: [RootEffect, ReadDirEffect,
    ReadEnvEffect, TimeEffect, ReadIOEffect, WriteIOEffect], forbids: [].}

Returns: Future[McpSubscription].

Arguments

Name	Type	Default
client	McpClient
notifications	JsonNode
handler	McpSubscriptionMessageHandler	nil

View source

subscribe (overload 2)

proc subscribe(client: McpClient; notifications: JsonNode;
               handler: McpSubscriptionMessageHandler = nil): McpSubscription {.
    raises: [ValueError, Exception, OSError, McpClientError, CatchableError], tags: [
    TimeEffect, RootEffect, ReadDirEffect, ReadEnvEffect, ReadIOEffect,
    WriteIOEffect], forbids: [].}

Returns: McpSubscription.

Arguments

Name	Type	Default
client	McpClient
notifications	JsonNode
handler	McpSubscriptionMessageHandler	nil

View source

asToolsAsync

Adapt discovered MCP tools into executable nimgent tools.

proc asToolsAsync(client: McpClient; prefix = ""): Future[seq[Tool]] {.
    stackTrace: false, raises: [Exception, ValueError, McpClientError, KeyError,
                                LibraryError, SslError, IOError], tags: [
    RootEffect, ReadDirEffect, ReadEnvEffect, TimeEffect, ReadIOEffect,
    WriteIOEffect], forbids: [].}

Returns: Future[seq[Tool]].

Arguments

Name	Type	Default
client	McpClient
prefix	inferred	""

View source

asTools

Synchronously adapt discovered MCP tools into executable tools.

proc asTools(client: McpClient; prefix = ""): seq[Tool] {.raises: [ValueError,
    Exception, OSError, McpClientError, KeyError, LibraryError, SslError,
    IOError], tags: [TimeEffect, RootEffect, ReadDirEffect, ReadEnvEffect,
                     ReadIOEffect, WriteIOEffect], forbids: [].}

Returns: seq[Tool].

Arguments

Name	Type	Default
client	McpClient
prefix	inferred	""

View source

closeAsync

Stop a live MCP subscription and release its local event stream.

proc closeAsync(subscription: McpSubscription): Future[void] {.
    stackTrace: false, raises: [Exception, McpClientError, KeyError,
                                LibraryError, SslError, IOError, ValueError],
    tags: [RootEffect, ReadDirEffect, ReadEnvEffect, TimeEffect, ReadIOEffect],
    forbids: [].}

Returns: Future[void].

Arguments

Name	Type	Default
subscription	McpSubscription

View source

close (overload 2)

proc close(subscription: McpSubscription) {.raises: [Exception, McpClientError,
    KeyError, LibraryError, SslError, IOError, ValueError],
    tags: [RootEffect, ReadDirEffect, ReadEnvEffect, TimeEffect, ReadIOEffect],
    forbids: [].}

Arguments

Name	Type	Default
subscription	McpSubscription

View source