agent-as-model 0.1.0__py3-none-any.whl

agent_as_model/__init__.py

@@ -0,0 +1,3 @@
+"""agent-as-model: a true MCP server where the agent is the model and the API key."""
+
+__version__ = "0.1.0"

agent_as_model/__main__.py

@@ -0,0 +1,6 @@
+"""Run the agent-as-model MCP server: python -m agent_as_model."""
+
+from agent_as_model.server import main
+
+if __name__ == "__main__":
+    main()

agent_as_model/protocol.py

@@ -0,0 +1,95 @@
+"""Message translation for agent-as-model.
+
+The server never touches a model API key. Every completion is produced by the
+host agent's own LLM through MCP sampling (or the multi-round-trip successor
+on 2026-07-28+ connections). This module translates the two most common
+product API shapes into MCP sampling messages and extracts plain text from
+sampling results.
+"""
+
+from __future__ import annotations
+
+from typing import Literal
+
+from mcp.types import CreateMessageResult, SamplingMessage, TextContent
+from pydantic import BaseModel
+
+
+class ChatMessage(BaseModel):
+    """One OpenAI chat-completions message (text content only, v1)."""
+
+    role: Literal["user", "assistant", "system"]
+    content: str
+
+
+class AnthropicContentBlock(BaseModel):
+    """One Anthropic text content block (v1 supports text only)."""
+
+    type: Literal["text"]
+    text: str
+
+
+class AnthropicMessage(BaseModel):
+    """One Anthropic messages API message (text only, v1)."""
+
+    role: Literal["user", "assistant"]
+    content: str | list[AnthropicContentBlock]
+
+
+def _text_of(content: str | list[AnthropicContentBlock]) -> str:
+    if isinstance(content, str):
+        return content
+    return "\n".join(block.text for block in content)
+
+
+def openai_to_sampling(
+    messages: list[ChatMessage],
+) -> tuple[str | None, list[SamplingMessage]]:
+    """Split OpenAI chat messages into a system prompt and sampling messages."""
+    if not messages:
+        raise ValueError("messages must be a non-empty list")
+    system_parts: list[str] = []
+    sampling: list[SamplingMessage] = []
+    for message in messages:
+        if message.role == "system":
+            system_parts.append(message.content)
+        else:
+            sampling.append(
+                SamplingMessage(
+                    role=message.role,
+                    content=TextContent(type="text", text=message.content),
+                )
+            )
+    system_prompt = "\n\n".join(system_parts) if system_parts else None
+    return system_prompt, sampling
+
+
+def anthropic_to_sampling(
+    messages: list[AnthropicMessage],
+    system: str | list[AnthropicContentBlock] | None,
+) -> tuple[str | None, list[SamplingMessage]]:
+    """Split an Anthropic messages request into a system prompt and sampling messages."""
+    if not messages:
+        raise ValueError("messages must be a non-empty list")
+    system_prompt = _text_of(system) if system is not None else None
+    sampling = [
+        SamplingMessage(
+            role=message.role,
+            content=TextContent(type="text", text=_text_of(message.content)),
+        )
+        for message in messages
+    ]
+    return system_prompt, sampling
+
+
+def extract_text(result: CreateMessageResult) -> str:
+    """Pull plain text out of a sampling result.
+
+    Raises ValueError on non-text content instead of silently stringifying it.
+    """
+    content = result.content
+    if isinstance(content, TextContent):
+        return content.text
+    raise ValueError(
+        f"agent-as-model serves text completions only, the host returned {type(content).__name__}"
+    )

agent_as_model/server.py

@@ -0,0 +1,162 @@
+"""agent-as-model: a true MCP server where the agent IS the model and the API key.
+
+Install on any MCP host (Claude Code, Cursor, Windsurf, ...). The server
+exposes product-style completion tools; every call is fulfilled by sampling
+the host agent's own LLM. No API keys exist anywhere in this system.
+
+Tools:
+  chat_complete   OpenAI chat-completions-shaped request -> completion text
+  messages_create Anthropic messages-shaped request -> completion text
+  list_models     the model this server offers (the host's own model, aliased)
+
+Upstream note: sampling is deprecated as of the 2026-07-28 spec (SEP-2577,
+earliest removal 2027-07-28). This server uses the era-portable
+Resolve/Sample form: a direct sampling request on pre-2026 connections and
+the multi-round-trip pattern on 2026-07-28+. One tool body serves both eras.
+The host must declare the sampling capability or calls fail with a clear
+MISSING_REQUIRED_CLIENT_CAPABILITY error.
+"""
+
+from __future__ import annotations
+
+import json
+from typing import Annotated
+
+from mcp.server.mcpserver import MCPServer, Resolve, Sample
+from mcp.types import (
+    CreateMessageResult,
+    ModelHint,
+    ModelPreferences,
+)
+from pydantic import Field
+
+from agent_as_model import __version__
+from agent_as_model.protocol import (
+    AnthropicContentBlock,
+    AnthropicMessage,
+    ChatMessage,
+    anthropic_to_sampling,
+    extract_text,
+    openai_to_sampling,
+)
+
+mcp = MCPServer(
+    name="agent-as-model",
+    version=__version__,
+    instructions=(
+        "Completion tools backed by the host agent's own model. "
+        "No API keys are used or needed: the connected agent is the model."
+    ),
+)
+
+
+async def _sample_chat(
+    messages: list[ChatMessage],
+    model: str,
+    temperature: float | None,
+    max_tokens: int,
+) -> Sample:
+    system_prompt, sampling_messages = openai_to_sampling(messages)
+    return Sample(
+        messages=sampling_messages,
+        system_prompt=system_prompt,
+        max_tokens=max_tokens,
+        temperature=temperature,
+        model_preferences=ModelPreferences(hints=[ModelHint(name=model)]),
+    )
+
+
+@mcp.tool(
+    description=(
+        "Generate a chat completion from an OpenAI chat-completions-shaped request. "
+        "The completion is produced by the host agent's own model via MCP sampling. "
+        "No API key is used or needed: the connected agent is the model."
+    )
+)
+async def chat_complete(
+    completion: Annotated[CreateMessageResult, Resolve(_sample_chat)],
+    messages: Annotated[
+        list[ChatMessage],
+        Field(description="Chat messages; system roles become the system prompt."),
+    ],
+    model: Annotated[
+        str, Field(description="Model alias; agent-default means the host's own model.")
+    ] = "agent-default",
+    temperature: Annotated[
+        float | None, Field(description="Sampling temperature, if the host honors it.")
+    ] = None,
+    max_tokens: Annotated[int, Field(description="Maximum tokens to generate.")] = 4096,
+) -> str:
+    """Complete a chat with the host agent's model (OpenAI request shape)."""
+    return extract_text(completion)
+
+
+async def _sample_messages(
+    messages: list[AnthropicMessage],
+    system: str | list[AnthropicContentBlock] | None,
+    model: str,
+    temperature: float | None,
+    max_tokens: int,
+) -> Sample:
+    system_prompt, sampling_messages = anthropic_to_sampling(messages, system)
+    return Sample(
+        messages=sampling_messages,
+        system_prompt=system_prompt,
+        max_tokens=max_tokens,
+        temperature=temperature,
+        model_preferences=ModelPreferences(hints=[ModelHint(name=model)]),
+    )
+
+
+@mcp.tool(
+    description=(
+        "Generate a completion from an Anthropic messages-shaped request. "
+        "The completion is produced by the host agent's own model via MCP sampling. "
+        "No API key is used or needed: the connected agent is the model."
+    )
+)
+async def messages_create(
+    completion: Annotated[CreateMessageResult, Resolve(_sample_messages)],
+    messages: Annotated[
+        list[AnthropicMessage], Field(description="User/assistant messages in order.")
+    ],
+    model: Annotated[
+        str, Field(description="Model alias; agent-default means the host's own model.")
+    ] = "agent-default",
+    system: Annotated[
+        str | list[AnthropicContentBlock] | None,
+        Field(description="System prompt as text or text blocks."),
+    ] = None,
+    temperature: Annotated[
+        float | None, Field(description="Sampling temperature, if the host honors it.")
+    ] = None,
+    max_tokens: Annotated[int, Field(description="Maximum tokens to generate.")] = 4096,
+) -> str:
+    """Complete a conversation with the host agent's model (Anthropic request shape)."""
+    return extract_text(completion)
+
+
+@mcp.tool(
+    description="List the models this server offers. There is exactly one: agent-default, an alias for the host agent's own model."
+)
+async def list_models() -> str:
+    """List available models (the host's own model, aliased)."""
+    return json.dumps(
+        [
+            {
+                "id": "agent-default",
+                "owned_by": "host-agent",
+                "description": (
+                    "Alias for the MCP host's own model, reached via sampling. No API key required."
+                ),
+            }
+        ]
+    )
+
+
+def main() -> None:
+    mcp.run_stdio_async()
+
+
+if __name__ == "__main__":
+    main()

agent_as_model-0.1.0.dist-info/METADATA

@@ -0,0 +1,130 @@
+Metadata-Version: 2.4
+Name: agent-as-model
+Version: 0.1.0
+Summary: A true MCP server where the agent is the model and the API key.
+Author: Fernando Garza
+License: MIT
+Project-URL: Homepage, https://github.com/fernandogarzaaa/agent-as-model
+Project-URL: Repository, https://github.com/fernandogarzaaa/agent-as-model
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: mcp<3,>=2
+Dynamic: license-file
+
+# agent-as-model
+
+A true MCP server where the agent **is** the model and the API key.
+
+Install it on any MCP host (Claude Code, Cursor, Windsurf, any spec-compliant
+client). It exposes product-style completion tools. Every call is fulfilled by
+sampling the host agent's own LLM. No API keys exist anywhere in this system.
+
+## The idea
+
+AI products usually demand a model API key before they do anything useful.
+This server flips that around. The tools speak the request shapes products
+already use, and the intelligence comes from the agent on the other end of
+the MCP connection. The agent is the model. The agent is the key.
+
+## Install
+
+Requires Python 3.10+ and a host that declares the MCP `sampling`
+capability. No API keys, ever.
+
+Run it straight from the repo with uvx (no install step):
+
+```bash
+claude mcp add agent-as-model -- uvx --from git+https://github.com/fernandogarzaaa/agent-as-model agent-as-model
+```
+
+Or install it for real:
+
+```bash
+pipx install git+https://github.com/fernandogarzaaa/agent-as-model
+# then
+claude mcp add agent-as-model -- agent-as-model
+```
+
+Cursor, Windsurf, or any client that takes MCP JSON:
+
+```json
+{
+  "mcpServers": {
+    "agent-as-model": {
+      "command": "uvx",
+      "args": ["--from", "git+https://github.com/fernandogarzaaa/agent-as-model", "agent-as-model"]
+    }
+  }
+}
+```
+
+From a local checkout: `python -m agent_as_model`.
+
+## Tools
+
+**chat_complete** — OpenAI chat-completions-shaped request, completion text back.
+
+```json
+{
+  "messages": [
+    {"role": "system", "content": "You are terse."},
+    {"role": "user", "content": "Explain MCP sampling."}
+  ],
+  "model": "agent-default",
+  "temperature": 0.7,
+  "max_tokens": 500
+}
+```
+
+**messages_create** — Anthropic messages-shaped request, completion text back.
+`system` accepts a string or a list of text blocks. Message content accepts a
+string or a list of text blocks.
+
+**list_models** — returns the one model this server offers: `agent-default`,
+an alias for the host agent's own model.
+
+## How it works
+
+1. A product (or agent) calls `chat_complete` with ordinary chat messages.
+2. The server translates them into MCP sampling messages and asks the host
+   to complete them. On pre-2026 connections this is a direct
+   `sampling/createMessage` request. On 2026-07-28+ it rides the
+   multi-round-trip pattern. One tool body serves both eras.
+3. The host agent generates the completion with its own model and the server
+   returns the text. The `model` argument is passed to the host as a model
+   hint only; `agent-default` means "your own model".
+
+## Honest caveats
+
+- Sampling is deprecated upstream (SEP-2577, spec 2026-07-28, earliest
+  removal 2027-07-28). The official migration path is provider API keys.
+  This project exists because the agent-as-model architecture is the point,
+  not the keys. The era-portable form used here is the sanctioned way to
+  keep it working across both spec eras.
+- The host is in charge. Sampling runs under the host's consent and policy.
+  A host without the sampling capability gets a clear
+  `MISSING_REQUIRED_CLIENT_CAPABILITY` error, not a silent failure.
+- Latency is one host model call per tool call. This is a thinking
+  endpoint, not a fast one.
+- v1 serves text only. Tool calls, images, and audio in either direction
+  are rejected with explicit errors, not silently dropped.
+
+## Roadmap
+
+- Provider-key fallback for hosts without sampling (opt-in, per-call choice
+  stays with the user).
+- Structured output passthrough where hosts support it.
+- More product shapes as tools (embeddings-shaped requests cannot be
+  sampled meaningfully; out of scope by design).
+
+## Development
+
+```bash
+python3 -m pytest tests/ -q
+python3 -m ruff format . && python3 -m ruff check .
+```
+
+14 tests, all green: message translation unit tests plus end-to-end runs of
+the full MCP loop (tool call to sampled completion) against a scripted host
+on both the modern multi-round-trip era and the legacy direct-sampling era.

agent_as_model-0.1.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+agent_as_model/__init__.py,sha256=DkLGJdKQjReesdGnBVoRMaHJYZ_52PboaNNgfdC0SVY,109
+agent_as_model/__main__.py,sha256=GPs1-oXObYgUM_MLZGYf-ejXgGOQ34nc2xkMYaGdDj8,146
+agent_as_model/protocol.py,sha256=iA0u6gofCVSCFIP2SkbytHFYilZHkhdBp8TegB0bv9I,3071
+agent_as_model/server.py,sha256=8y2IrLny7Q6VxOHxCQSy5Du1WGmkvggmeyaVU-hE8iM,5407
+agent_as_model-0.1.0.dist-info/licenses/LICENSE,sha256=VbqRYzR3eEfKB0qZfOnFyBS3eKnLpi_qjzqqkD7o028,1071
+agent_as_model-0.1.0.dist-info/METADATA,sha256=7kCPJMcccCaiHvvqjvz8Z1_NBf8bUrIePqEOZppYX1w,4423
+agent_as_model-0.1.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+agent_as_model-0.1.0.dist-info/entry_points.txt,sha256=UWxSor6R970wuPCtSooNp8kCCpMo_olPykJFzeITkX0,62
+agent_as_model-0.1.0.dist-info/top_level.txt,sha256=9TogFQ2wHtPGqeRkYQD9gplJXFGIV8-FaX-j8rCf1gY,15
+agent_as_model-0.1.0.dist-info/RECORD,,

agent_as_model-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

agent_as_model-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+agent-as-model = agent_as_model.server:main

agent_as_model-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Fernando Garza
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

agent_as_model-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+agent_as_model