Metadata-Version: 2.4
Name: mint-semantic-kernel
Version: 0.1.0
Summary: MINT Protocol plugin for Microsoft Semantic Kernel — universal work attestation for AI agents.
Project-URL: Homepage, https://mint.foundrynet.io
Project-URL: Source, https://github.com/FoundryNet/mint-semantic-kernel
Project-URL: Documentation, https://mint.foundrynet.io
Author-email: FoundryNet <hello@foundrynet.io>
License-Expression: MIT
License-File: LICENSE
Keywords: agent,attestation,mint,plugin,reputation,semantic-kernel,trust,verification
Requires-Python: >=3.10
Requires-Dist: mint-attest>=0.3.1
Requires-Dist: semantic-kernel>=1.0.0
Provides-Extra: dev
Requires-Dist: pytest>=7; extra == 'dev'
Requires-Dist: ruff>=0.4; extra == 'dev'
Description-Content-Type: text/markdown

# MINT Protocol plugin for Semantic Kernel

**Give your Semantic Kernel agent verifiable proof of the work it does.**

A [Microsoft Semantic Kernel](https://github.com/microsoft/semantic-kernel) plugin
for [MINT Protocol](https://mint.foundrynet.io) — universal **work attestation** for
AI agents. Add it to a kernel and your agent can turn any completed task into a
tamper-evident, independently verifiable receipt, build a portable track record of
trust and reputation, and check or discover how trustworthy other agents are before
relying on them.

Why agent builders care:

- **Provable work** — every task produces a receipt with a public `verify_url`
  anyone can check.
- **Portable reputation** — a trust score and rating history that follow the agent,
  not locked inside one platform.
- **Trust-aware delegation** — verify another actor, and discover trusted
  agents/services by capability.
- **Zero crypto knowledge required** — every tool is a plain authenticated HTTPS
  call; the agent never touches a wallet or signs anything.

The five tools:

| Tool | What it does |
| --- | --- |
| `attest_work` | Turn a completed unit of work into a tamper-evident, independently verifiable receipt with a public `verify_url` (inputs/outputs hashed client-side). |
| `verify_trust` | Look up any actor's trust profile (trust score, attestations, ratings). Free. |
| `discover_agents` | Trust-ranked directory search by capability. Free. |
| `rate_attestation` | Rate a completed attestation 1-5. |
| `recommend_actor` | Endorse another actor in a named context 1-5. |

> This plugin is hosted in its own repository, per Semantic Kernel's
> [contribution guidelines](https://github.com/microsoft/semantic-kernel/blob/main/CONTRIBUTING.md#plugins)
> ("we encourage contributors to host their plugin code in separate repositories").

## Installation

```bash
pip install git+https://github.com/FoundryNet/mint-semantic-kernel
```

## Authentication

Get a `fnet_` API key at [mint.foundrynet.io](https://mint.foundrynet.io) and pass
it as `api_key` (or set the `MINT_API_KEY` environment variable). Reads
(`verify_trust`, `discover_agents`) are free and need no key.

## Usage (native plugin)

```python
from semantic_kernel import Kernel
from mint_semantic_kernel import MintPlugin

kernel = Kernel()
kernel.add_plugin(MintPlugin(api_key="fnet_...", name="my-agent"), plugin_name="mint")

# ...add a chat service with FunctionChoiceBehavior.Auto() and the agent can now
# attest its work, verify trust, and discover other agents on its own.
```

See [`samples/mint_plugin_demo.py`](samples/mint_plugin_demo.py) for a complete,
runnable example with OpenAI function calling.

## Usage (MCP server, no SDK)

MINT is also a remote MCP server on
[Smithery](https://smithery.ai/server/@foundrynet/mint-protocol). If you'd rather
connect over MCP than use the native plugin, Semantic Kernel can mount it directly:

```python
from semantic_kernel import Kernel
from semantic_kernel.connectors.mcp import MCPStreamableHttpPlugin

async with MCPStreamableHttpPlugin(
    name="mint",
    url="https://mint-mcp-production.up.railway.app/mcp",
    headers={"Authorization": "Bearer fnet_..."},
) as mint:
    kernel = Kernel()
    kernel.add_plugin(mint)
```

## How it works

Each receipt is anchored on a public ledger (Solana mainnet) so it's tamper-evident
and verifiable by anyone, independent of MINT or your agent — that's what makes the
proof portable rather than just a log line you control. All of it happens
server-side: the agent only makes authenticated HTTPS calls, never handles keys or
signs transactions, and you don't need to know or care which chain anchors it. This
plugin is a thin wrapper over the
[`mint-attest`](https://pypi.org/project/mint-attest/) SDK.

## Development

```bash
pip install -e ".[dev]"
pytest
```

## Links

- MINT Protocol: https://mint.foundrynet.io
- `mint-attest` SDK (PyPI): https://pypi.org/project/mint-attest/
- MCP server (Smithery): https://smithery.ai/server/@foundrynet/mint-protocol

## License

MIT — see [LICENSE](LICENSE).
