harnest.mcp - Fused

All Python modules · Import and compatibility guidance

Discovery operations

The facade also exposes inspect(), list_tools(cursor=None), list_resources(cursor=None), list_resource_templates(cursor=None), list_prompts(cursor=None), and get_prompt(name, arguments=None). Inspection and tool-catalogue listing are developer operations, not additional model tools.

Exports

Name	Kind
`MCPClient`	Class
`MCPClientContext`	Class
`MCPClientLifecycle`	Class
`MCPClientUnavailableError`	Class
`MCPContext`	Class
`MCPContextUnavailableError`	Class
`MCPHTTPClientOptions`	Class
`MCPLifecycleError`	Class
`MCPLifecyclePipeline`	Class
`MCPResourceClient`	Class
`MCPResourceError`	Class
`MCPResourceEvent`	Class
`MCPSubscription`	Class
`MCPToolCallError`	Class
`MCPToolCallRequest`	Class
`MCPToolLifecycleContext`	Class
`MCPToolUnavailableError`	Class
`ManagedMCPClient`	Class

MCPClient

A client connection to a stdio, SSE, or Streamable HTTP MCP server. Obtain this object from the owning Harnest API; its constructor includes runtime bindings. Fields (— means no declared default):

Field	Type	Default
`transport`	`str`	`—`
`command`	`str \| None`	`None`
`args`	`Sequence[str]`	`tuple()`
`env`	`Mapping[str, str]`	`dict()`
`url`	`str \| None`	`None`
`headers`	`Mapping[str, str]`	`dict()`
`tool_filter`	`Sequence[str] \| None`	`None`
`tool_name_prefix`	`str \| None`	`None`
`timeout_seconds`	`float`	`30`
`sse_read_timeout_seconds`	`float`	`300`
`approval`	`ApprovalPolicy \| None`	`None`
`identity`	`str \| None`	`None`
`capability_id`	`str \| None`	`None`
`lifecycle`	`MCPClientLifecycle \| None`	`None`
`cwd`	`str \| None`	`None`
`portable`	`Any`	`None`
`permission`	`str \| None`	`None`
`tool_permissions`	`Mapping[str, str]`	`dict()`
`resources`	`Sequence[str] \| None`	`None`
`prompts`	`Sequence[str] \| None`	`None`
`max_content_bytes`	`int`	`1048576`
`subscriptions`	`Sequence[MCPSubscription]`	`tuple()`

Example

from harnest.mcp import MCPClient

client: MCPClient  # returned by Harnest, not constructed directly

MCPClient.from_openapi

MCPClient.from_openapi(
    source: str | Path,
    *,
    base_url: str | None = None,
    headers: Mapping[str, str] | None = None,
    **client_options: Any,
) -> 'MCPClient'

Connect to a local or remote spec through a runtime OpenAPI bridge. Reading and conversion happen when the MCP connection opens, never during authoring or compilation. Use a path relative to __file__ for specs bundled with an agent. Headers support ${VARIABLE}. client_options accepts the standard stdio policy options. Requires the optional harnest[openapi] runtime dependency.

Parameters and example

Parameter	Type	Default
`source`	`str \| Path`	Required
`base_url`	`str \| None`	`None`
`headers`	`Mapping[str, str] \| None`	`None`
`**client_options`	`Any`	Optional

from harnest.mcp import MCPClient

client = MCPClient.from_openapi(source=...)

MCPClient.stdio

MCPClient.stdio(
    command: str,
    *args: str,
    env: Mapping[str, str] | None = None,
    tools: Sequence[str] | None = None,
    prefix: str | None = None,
    permission: str | None = None,
    tool_permissions: Mapping[str, str] | None = None,
    timeout_seconds: float = 30,
    lifecycle: MCPClientLifecycle | None = None,
    resources: Sequence[str] | None = None,
    prompts: Sequence[str] | None = None,
    max_content_bytes: int = 1048576,
    subscriptions: Sequence[MCPSubscription] = (),
) -> 'MCPClient'

Create an MCP client that starts and communicates with a subprocess.

Parameters and example

Parameter	Type	Default
`command`	`str`	Required
`*args`	`str`	Optional
`env`	`Mapping[str, str] \| None`	`None`
`tools`	`Sequence[str] \| None`	`None`
`prefix`	`str \| None`	`None`
`permission`	`str \| None`	`None`
`tool_permissions`	`Mapping[str, str] \| None`	`None`
`timeout_seconds`	`float`	`30`
`lifecycle`	`MCPClientLifecycle \| None`	`None`
`resources`	`Sequence[str] \| None`	`None`
`prompts`	`Sequence[str] \| None`	`None`
`max_content_bytes`	`int`	`1048576`
`subscriptions`	`Sequence[MCPSubscription]`	`()`

from harnest.mcp import MCPClient

client = MCPClient.stdio(command=...)

MCPClient.streamable_http

MCPClient.streamable_http(
    url: str,
    *,
    headers: Mapping[str, str] | None = None,
    tools: Sequence[str] | None = None,
    prefix: str | None = None,
    permission: str | None = None,
    tool_permissions: Mapping[str, str] | None = None,
    timeout_seconds: float = 30,
    sse_read_timeout_seconds: float = 300,
    lifecycle: MCPClientLifecycle | None = None,
    resources: Sequence[str] | None = None,
    prompts: Sequence[str] | None = None,
    max_content_bytes: int = 1048576,
    subscriptions: Sequence[MCPSubscription] = (),
) -> 'MCPClient'

Create an MCP client using the Streamable HTTP transport.

Parameters and example

Parameter	Type	Default
`url`	`str`	Required
`headers`	`Mapping[str, str] \| None`	`None`
`tools`	`Sequence[str] \| None`	`None`
`prefix`	`str \| None`	`None`
`permission`	`str \| None`	`None`
`tool_permissions`	`Mapping[str, str] \| None`	`None`
`timeout_seconds`	`float`	`30`
`sse_read_timeout_seconds`	`float`	`300`
`lifecycle`	`MCPClientLifecycle \| None`	`None`
`resources`	`Sequence[str] \| None`	`None`
`prompts`	`Sequence[str] \| None`	`None`
`max_content_bytes`	`int`	`1048576`
`subscriptions`	`Sequence[MCPSubscription]`	`()`

from harnest.mcp import MCPClient

client = MCPClient.streamable_http(url=...)

MCPClient.sse

MCPClient.sse(
    url: str,
    *,
    headers: Mapping[str, str] | None = None,
    tools: Sequence[str] | None = None,
    prefix: str | None = None,
    permission: str | None = None,
    tool_permissions: Mapping[str, str] | None = None,
    timeout_seconds: float = 30,
    sse_read_timeout_seconds: float = 300,
    lifecycle: MCPClientLifecycle | None = None,
    resources: Sequence[str] | None = None,
    prompts: Sequence[str] | None = None,
    max_content_bytes: int = 1048576,
    subscriptions: Sequence[MCPSubscription] = (),
) -> 'MCPClient'

Create an MCP client using the legacy HTTP/SSE transport.

Parameters and example

Parameter	Type	Default
`url`	`str`	Required
`headers`	`Mapping[str, str] \| None`	`None`
`tools`	`Sequence[str] \| None`	`None`
`prefix`	`str \| None`	`None`
`permission`	`str \| None`	`None`
`tool_permissions`	`Mapping[str, str] \| None`	`None`
`timeout_seconds`	`float`	`30`
`sse_read_timeout_seconds`	`float`	`300`
`lifecycle`	`MCPClientLifecycle \| None`	`None`
`resources`	`Sequence[str] \| None`	`None`
`prompts`	`Sequence[str] \| None`	`None`
`max_content_bytes`	`int`	`1048576`
`subscriptions`	`Sequence[MCPSubscription]`	`()`

from harnest.mcp import MCPClient

client = MCPClient.sse(url=...)

MCPClient.connect

MCPClient.connect(*, framework: Literal['adk', 'langgraph'] = 'langgraph') -> Any

Open a developer-owned read client using the configured lifecycle and credentials.

Parameters and example

Parameter	Type	Default
`framework`	`Literal['adk', 'langgraph']`	`'langgraph'`

from harnest.mcp import MCPClient

client: MCPClient
result = client.connect()

MCPClient.required_permissions_for

MCPClient.required_permissions_for(tool_name: str) -> frozenset[str]

Combine an optional client requirement with one remote-tool requirement.

Parameters and example

Parameter	Type	Default
`tool_name`	`str`	Required

from harnest.mcp import MCPClient

client: MCPClient
result = client.required_permissions_for(tool_name=...)

MCPClient.to_adk_toolset

MCPClient.to_adk_toolset() -> Any

Use native transport while preserving portable expansion and failure rules.

Example

from harnest.mcp import MCPClient

client: MCPClient
result = client.to_adk_toolset()

MCPClient.to_langgraph_connection

MCPClient.to_langgraph_connection() -> dict[str, Any]

Return a LangChain MCP adapter connection without opening it.

Example

from harnest.mcp import MCPClient

client: MCPClient
result = client.to_langgraph_connection()

MCPClientContext

Privacy-safe identity supplied to an MCP client lifecycle.

MCPClientContext(
    name: str,
    transport: Literal['stdio', 'sse', 'streamable-http'],
    framework: MCPFramework,
    url: str,
) -> None

Fields (— means no declared default):

Field	Type	Default
`name`	`str`	`—`
`transport`	`Literal['stdio', 'sse', 'streamable-http']`	`—`
`framework`	`MCPFramework`	`—`
`url`	`str`	`—`

Parameters and example

Parameter	Type	Default
`name`	`str`	Required
`transport`	`Literal['stdio', 'sse', 'streamable-http']`	Required
`framework`	`MCPFramework`	Required
`url`	`str`	Required

from harnest.mcp import MCPClientContext

context = MCPClientContext(name=..., transport=..., framework=..., url=...)

MCPClientLifecycle

Customize one remote MCP connection’s HTTP client lifecycle. start and close run once for the compiled application. The synchronous create_http_client hook runs for every MCP session because ADK and LangGraph own and close those session-scoped HTTP clients.

MCPClientLifecycle()

Example

from harnest.mcp import MCPClientLifecycle

lifecycle = MCPClientLifecycle()

MCPClientLifecycle.start

MCPClientLifecycle.start(context: MCPClientContext) -> MCPLifecycleValue

Initialize credential, certificate, or gateway support resources.

Parameters and example

Parameter	Type	Default
`context`	`MCPClientContext`	Required

from harnest.mcp import MCPClientLifecycle

lifecycle: MCPClientLifecycle
result = lifecycle.start(context=...)

MCPClientLifecycle.create_http_client

MCPClientLifecycle.create_http_client(options: MCPHTTPClientOptions, context: MCPClientContext) -> Any

Return a proxy-aware httpx.AsyncClient with safe diagnostics.

Parameters and example

Parameter	Type	Default
`options`	`MCPHTTPClientOptions`	Required
`context`	`MCPClientContext`	Required

from harnest.mcp import MCPClientLifecycle

lifecycle: MCPClientLifecycle
result = lifecycle.create_http_client(options=..., context=...)

MCPClientLifecycle.close

MCPClientLifecycle.close(context: MCPClientContext) -> MCPLifecycleValue

Release application-level resources created by start.

Parameters and example

Parameter	Type	Default
`context`	`MCPClientContext`	Required

from harnest.mcp import MCPClientLifecycle

lifecycle: MCPClientLifecycle
result = lifecycle.close(context=...)

MCPClientUnavailableError

Raised when an invocation cannot access a named managed MCP client.

Example

from harnest.mcp import MCPClientUnavailableError

try:
    ...
except MCPClientUnavailableError as error:
    ...

MCPContext

Resolve managed MCP clients without exposing the client registry.

MCPContext()

Example

from harnest.mcp import MCPContext

context = MCPContext()

MCPContext.call

MCPContext.__call__(name: str) -> ManagedMCPClient

Return one named managed client for concise context access.

Parameters and example

Parameter	Type	Default
`name`	`str`	Required

from harnest.mcp import MCPContext

context: MCPContext
client = context(name=...)

MCPContext.client

MCPContext.client(name: str) -> ManagedMCPClient

Return one named client or fail without enumerating capabilities.

Parameters and example

Parameter	Type	Default
`name`	`str`	Required

from harnest.mcp import MCPContext

context: MCPContext
client = context.client(name=...)

MCPContextUnavailableError

Raised when managed MCP access has no active invocation binding.

Example

from harnest.mcp import MCPContextUnavailableError

try:
    ...
except MCPContextUnavailableError as error:
    ...

MCPHTTPClientOptions

Adapter-provided inputs for one MCP HTTP client instance.

MCPHTTPClientOptions(headers: Mapping[str, str], timeout: Any = None, auth: Any = None) -> None

Fields (— means no declared default):

Field	Type	Default
`headers`	`Mapping[str, str]`	`—`
`timeout`	`Any`	`None`
`auth`	`Any`	`None`

Parameters and example

Parameter	Type	Default
`headers`	`Mapping[str, str]`	Required
`timeout`	`Any`	`None`
`auth`	`Any`	`None`

from harnest.mcp import MCPHTTPClientOptions

options = MCPHTTPClientOptions(headers=...)

MCPLifecycleError

An MCP interceptor returned invalid or ambiguous control flow.

Example

from harnest.mcp import MCPLifecycleError

try:
    ...
except MCPLifecycleError as error:
    ...

MCPLifecyclePipeline

Apply explicit portable interceptors around one managed MCP call.

MCPLifecyclePipeline(listeners: Sequence[LifecycleListener]) -> None

Parameters and example

Parameter	Type	Default
`listeners`	`Sequence[LifecycleListener]`	Required

from harnest.mcp import MCPLifecyclePipeline

pipeline = MCPLifecyclePipeline(listeners=...)

MCPLifecyclePipeline.run

async MCPLifecyclePipeline.run(
    request: MCPToolCallRequest,
    handler: Callable[[MCPToolCallRequest], Awaitable[Any]],
    context: MCPToolLifecycleContext,
) -> _MCPExecution

Run one call, allowing explicit short-circuit and safe recovery.

Parameters and example

Parameter	Type	Default
`request`	`MCPToolCallRequest`	Required
`handler`	`Callable[[MCPToolCallRequest], Awaitable[Any]]`	Required
`context`	`MCPToolLifecycleContext`	Required

from harnest.mcp import MCPLifecyclePipeline

pipeline: MCPLifecyclePipeline
execution = await pipeline.run(request=..., handler=..., context=...)

MCPResourceClient

Connection-bound read API; resource data never becomes system instructions.

MCPResourceClient(configured: Any, *, framework: str = 'langgraph') -> None

Parameters and example

Parameter	Type	Default
`configured`	`Any`	Required
`framework`	`str`	`'langgraph'`

from harnest.mcp import MCPResourceClient

client = MCPResourceClient(configured=...)

MCPResourceClient.inspect

async MCPResourceClient.inspect() -> dict[str, Any]

Discover capability metadata without reading resources or rendering prompts.

Example

from harnest.mcp import MCPResourceClient

client: MCPResourceClient
result = await client.inspect()

MCPResourceClient.list_tools

async MCPResourceClient.list_tools(cursor: str | None = None) -> dict[str, Any]

List one page of remote tool schemas under the configured tool policy.

Parameters and example

Parameter	Type	Default
`cursor`	`str \| None`	`None`

from harnest.mcp import MCPResourceClient

client: MCPResourceClient
result = await client.list_tools()

MCPResourceClient.list_resources

async MCPResourceClient.list_resources(cursor: str | None = None) -> dict[str, Any]

Return one bounded page with the server’s opaque nextCursor unchanged.

Parameters and example

Parameter	Type	Default
`cursor`	`str \| None`	`None`

from harnest.mcp import MCPResourceClient

client: MCPResourceClient
result = await client.list_resources()

MCPResourceClient.list_resource_templates

async MCPResourceClient.list_resource_templates(cursor: str | None = None) -> dict[str, Any]

Discover parameterized resource URIs without fetching their contents.

Parameters and example

Parameter	Type	Default
`cursor`	`str \| None`	`None`

from harnest.mcp import MCPResourceClient

client: MCPResourceClient
result = await client.list_resource_templates()

MCPResourceClient.list_prompts

async MCPResourceClient.list_prompts(cursor: str | None = None) -> dict[str, Any]

Discover prompt descriptions and declared arguments.

Parameters and example

Parameter	Type	Default
`cursor`	`str \| None`	`None`

from harnest.mcp import MCPResourceClient

client: MCPResourceClient
result = await client.list_prompts()

MCPResourceClient.read_resource

async MCPResourceClient.read_resource(uri: str) -> dict[str, Any]

Read an explicitly selected URI through MCP, never through a local file API.

Parameters and example

Parameter	Type	Default
`uri`	`str`	Required

from harnest.mcp import MCPResourceClient

client: MCPResourceClient
result = await client.read_resource(uri=...)

MCPResourceClient.get_prompt

async MCPResourceClient.get_prompt(name: str, arguments: Mapping[str, str] | None = None) -> dict[str, Any]

Retrieve prompt messages as untrusted data for explicit caller use.

Parameters and example

Parameter	Type	Default
`name`	`str`	Required
`arguments`	`Mapping[str, str] \| None`	`None`

from harnest.mcp import MCPResourceClient

client: MCPResourceClient
result = await client.get_prompt(name=...)

MCPResourceError

An MCP capability request failed without exposing connection credentials.

Example

from harnest.mcp import MCPResourceError

try:
    ...
except MCPResourceError as error:
    ...

MCPResourceEvent

One retained resource value; handlers decide whether to invoke an agent or task.

MCPResourceEvent(
    client_name: str,
    uri: str,
    resource: Mapping[str, Any],
    reason: Literal['start', 'update', 'reconnect'] = 'update',
) -> None

Fields (— means no declared default):

Field	Type	Default
`client_name`	`str`	`—`
`uri`	`str`	`—`
`resource`	`Mapping[str, Any]`	`—`
`reason`	`Literal['start', 'update', 'reconnect']`	`'update'`

Parameters and example

Parameter	Type	Default
`client_name`	`str`	Required
`uri`	`str`	Required
`resource`	`Mapping[str, Any]`	Required
`reason`	`Literal['start', 'update', 'reconnect']`	`'update'`

from harnest.mcp import MCPResourceEvent

event = MCPResourceEvent(client_name=..., uri=..., resource=...)

MCPSubscription

Opt in to a URI, an async application handler, and explicit recovery policy.

MCPSubscription(
    uri: str,
    handler: Callable[[MCPResourceEvent], Awaitable[None]],
    method: Literal['resources/subscribe', 'subscriptions/listen'] = 'resources/subscribe',
    read_on_start: bool = True,
    read_on_reconnect: bool = True,
    handler_timeout_seconds: float = 30,
) -> None

Fields (— means no declared default):

Field	Type	Default
`uri`	`str`	`—`
`handler`	`Callable[[MCPResourceEvent], Awaitable[None]]`	`—`
`method`	`Literal['resources/subscribe', 'subscriptions/listen']`	`'resources/subscribe'`
`read_on_start`	`bool`	`True`
`read_on_reconnect`	`bool`	`True`
`handler_timeout_seconds`	`float`	`30`

Parameters and example

Parameter	Type	Default
`uri`	`str`	Required
`handler`	`Callable[[MCPResourceEvent], Awaitable[None]]`	Required
`method`	`Literal['resources/subscribe', 'subscriptions/listen']`	`'resources/subscribe'`
`read_on_start`	`bool`	`True`
`read_on_reconnect`	`bool`	`True`
`handler_timeout_seconds`	`float`	`30`

from harnest.mcp import MCPSubscription

subscription = MCPSubscription(uri=..., handler=...)

MCPToolCallError

A provider-neutral failure from a discovered managed MCP tool.

Example

from harnest.mcp import MCPToolCallError

try:
    ...
except MCPToolCallError as error:
    ...

MCPToolCallRequest

Opaque remote arguments that a before hook may explicitly replace.

MCPToolCallRequest(arguments: Mapping[str, Any] = ...) -> None

Fields (— means no declared default):

Field	Type	Default
`arguments`	`Mapping[str, Any]`	`dict()`

Parameters and example

Parameter	Type	Default
`arguments`	`Mapping[str, Any]`	`...`

from harnest.mcp import MCPToolCallRequest

request = MCPToolCallRequest()

MCPToolLifecycleContext

Privacy-safe identity for one governed remote-tool execution.

MCPToolLifecycleContext(
    framework: str,
    agent_name: str,
    invocation_id: str,
    user_id: str,
    session_id: str,
    client_name: str,
    tool_name: str,
) -> None

Fields (— means no declared default):

Field	Type	Default
`framework`	`str`	`—`
`agent_name`	`str`	`—`
`invocation_id`	`str`	`—`
`user_id`	`str`	`—`
`session_id`	`str`	`—`
`client_name`	`str`	`—`
`tool_name`	`str`	`—`

Parameters and example

Parameter	Type	Default
`framework`	`str`	Required
`agent_name`	`str`	Required
`invocation_id`	`str`	Required
`user_id`	`str`	Required
`session_id`	`str`	Required
`client_name`	`str`	Required
`tool_name`	`str`	Required

from harnest.mcp import MCPToolLifecycleContext

context = MCPToolLifecycleContext(
    framework=...,
    agent_name=...,
    invocation_id=...,
    user_id=...,
    session_id=...,
    client_name=...,
    tool_name=...,
)

MCPToolLifecycleContext.next

MCPToolLifecycleContext.next(replacement: Any = UNCHANGED) -> Next[Any]

Continue normally or pass a replacement to the next interceptor.

Parameters and example

Parameter	Type	Default
`replacement`	`Any`	`UNCHANGED`

from harnest.mcp import MCPToolLifecycleContext

context: MCPToolLifecycleContext
result = context.next()

MCPToolLifecycleContext.finish

MCPToolLifecycleContext.finish(result: ResultT) -> Finish[ResultT]

Return a final value without advancing to later execution.

Parameters and example

Parameter	Type	Default
`result`	`ResultT`	Required

from harnest.mcp import MCPToolLifecycleContext

context: MCPToolLifecycleContext
result = context.finish(result=...)

MCPToolUnavailableError

Raised when a managed MCP client does not expose a requested tool.

Example

from harnest.mcp import MCPToolUnavailableError

try:
    ...
except MCPToolUnavailableError as error:
    ...

ManagedMCPClient

Named MCP facade with no access to credentials or raw transports. Obtain this object from the owning Harnest API; its constructor includes runtime bindings. Fields (— means no declared default):

Field	Type	Default
`name`	`str`	`—`

Example

from harnest.mcp import ManagedMCPClient

client: ManagedMCPClient  # returned by Harnest, not constructed directly

ManagedMCPClient.inspect

async ManagedMCPClient.inspect() -> Any

Discover bounded MCP catalogues through the invocation’s governed path.

Example

from harnest.mcp import ManagedMCPClient

client: ManagedMCPClient
result = await client.inspect()

ManagedMCPClient.list_resources

async ManagedMCPClient.list_resources(cursor: str | None = None) -> Any

List one resource page without reading its contents.

Parameters and example

Parameter	Type	Default
`cursor`	`str \| None`	`None`

from harnest.mcp import ManagedMCPClient

client: ManagedMCPClient
result = await client.list_resources()

ManagedMCPClient.list_tools

async ManagedMCPClient.list_tools(cursor: str | None = None) -> Any

List remote tool metadata within this invocation’s permission scope.

Parameters and example

Parameter	Type	Default
`cursor`	`str \| None`	`None`

from harnest.mcp import ManagedMCPClient

client: ManagedMCPClient
result = await client.list_tools()

ManagedMCPClient.list_resource_templates

async ManagedMCPClient.list_resource_templates(cursor: str | None = None) -> Any

List one page of parameterized resource URIs.

Parameters and example

Parameter	Type	Default
`cursor`	`str \| None`	`None`

from harnest.mcp import ManagedMCPClient

client: ManagedMCPClient
result = await client.list_resource_templates()

ManagedMCPClient.list_prompts

async ManagedMCPClient.list_prompts(cursor: str | None = None) -> Any

List prompt descriptions and arguments without rendering messages.

Parameters and example

Parameter	Type	Default
`cursor`	`str \| None`	`None`

from harnest.mcp import ManagedMCPClient

client: ManagedMCPClient
result = await client.list_prompts()

ManagedMCPClient.read_resource

async ManagedMCPClient.read_resource(uri: str) -> Any

Read an allowed MCP URI through the same audit and permission boundary.

Parameters and example

Parameter	Type	Default
`uri`	`str`	Required

from harnest.mcp import ManagedMCPClient

client: ManagedMCPClient
result = await client.read_resource(uri=...)

ManagedMCPClient.get_prompt

async ManagedMCPClient.get_prompt(name: str, arguments: Mapping[str, str] | None = None) -> Any

Return prompt messages as data, never as higher-priority instructions.

Parameters and example

Parameter	Type	Default
`name`	`str`	Required
`arguments`	`Mapping[str, str] \| None`	`None`

from harnest.mcp import ManagedMCPClient

client: ManagedMCPClient
result = await client.get_prompt(name=...)

ManagedMCPClient.call_tool

async ManagedMCPClient.call_tool(name: str, arguments: Mapping[str, Any] | None = None) -> Any

Dispatch one discovered tool through its governed shared path.

Parameters and example

Parameter	Type	Default
`name`	`str`	Required
`arguments`	`Mapping[str, Any] \| None`	`None`

from harnest.mcp import ManagedMCPClient

client: ManagedMCPClient
result = await client.call_tool(name=...)

​Discovery operations

​Exports

​MCPClient

​MCPClient.from_openapi

​MCPClient.stdio

​MCPClient.streamable_http

​MCPClient.sse

​MCPClient.connect

​MCPClient.required_permissions_for

​MCPClient.to_adk_toolset

​MCPClient.to_langgraph_connection

​MCPClientContext

​MCPClientLifecycle

​MCPClientLifecycle.start

​MCPClientLifecycle.create_http_client

​MCPClientLifecycle.close

​MCPClientUnavailableError

​MCPContext

​MCPContext.call

​MCPContext.client

​MCPContextUnavailableError

​MCPHTTPClientOptions

​MCPLifecycleError

​MCPLifecyclePipeline

​MCPLifecyclePipeline.run

​MCPResourceClient

​MCPResourceClient.inspect

​MCPResourceClient.list_tools

​MCPResourceClient.list_resources

​MCPResourceClient.list_resource_templates

​MCPResourceClient.list_prompts

​MCPResourceClient.read_resource

​MCPResourceClient.get_prompt

​MCPResourceError

​MCPResourceEvent

​MCPSubscription

​MCPToolCallError

​MCPToolCallRequest

​MCPToolLifecycleContext

​MCPToolLifecycleContext.next

​MCPToolLifecycleContext.finish

​MCPToolUnavailableError

​ManagedMCPClient

​ManagedMCPClient.inspect

​ManagedMCPClient.list_resources

​ManagedMCPClient.list_tools

​ManagedMCPClient.list_resource_templates

​ManagedMCPClient.list_prompts

​ManagedMCPClient.read_resource

​ManagedMCPClient.get_prompt

​ManagedMCPClient.call_tool

Discovery operations

Exports

MCPClient

MCPClient.from_openapi

MCPClient.stdio

MCPClient.streamable_http

MCPClient.sse

MCPClient.connect

MCPClient.required_permissions_for

MCPClient.to_adk_toolset

MCPClient.to_langgraph_connection

MCPClientContext

MCPClientLifecycle

MCPClientLifecycle.start

MCPClientLifecycle.create_http_client

MCPClientLifecycle.close

MCPClientUnavailableError

MCPContext

MCPContext.call

MCPContext.client

MCPContextUnavailableError

MCPHTTPClientOptions

MCPLifecycleError

MCPLifecyclePipeline

MCPLifecyclePipeline.run

MCPResourceClient

MCPResourceClient.inspect

MCPResourceClient.list_tools

MCPResourceClient.list_resources

MCPResourceClient.list_resource_templates

MCPResourceClient.list_prompts

MCPResourceClient.read_resource

MCPResourceClient.get_prompt

MCPResourceError

MCPResourceEvent

MCPSubscription

MCPToolCallError

MCPToolCallRequest

MCPToolLifecycleContext

MCPToolLifecycleContext.next

MCPToolLifecycleContext.finish

MCPToolUnavailableError

ManagedMCPClient

ManagedMCPClient.inspect

ManagedMCPClient.list_resources

ManagedMCPClient.list_tools

ManagedMCPClient.list_resource_templates

ManagedMCPClient.list_prompts

ManagedMCPClient.read_resource

ManagedMCPClient.get_prompt

ManagedMCPClient.call_tool