agent-as-model 0.1.0__tar.gz

agent_as_model-0.1.0/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/PKG-INFO

@@ -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/README.md

@@ -0,0 +1,116 @@
+# 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/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-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-0.1.0/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-0.1.0/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/agent_as_model.egg-info/PKG-INFO

@@ -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/agent_as_model.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+LICENSE
+README.md
+pyproject.toml
+agent_as_model/__init__.py
+agent_as_model/__main__.py
+agent_as_model/protocol.py
+agent_as_model/server.py
+agent_as_model.egg-info/PKG-INFO
+agent_as_model.egg-info/SOURCES.txt
+agent_as_model.egg-info/dependency_links.txt
+agent_as_model.egg-info/entry_points.txt
+agent_as_model.egg-info/requires.txt
+agent_as_model.egg-info/top_level.txt
+tests/test_protocol.py
+tests/test_server.py

agent_as_model-0.1.0/agent_as_model.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

agent_as_model-0.1.0/agent_as_model.egg-info/entry_points.txt

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

agent_as_model-0.1.0/agent_as_model.egg-info/requires.txt

@@ -0,0 +1 @@
+mcp<3,>=2

agent_as_model-0.1.0/agent_as_model.egg-info/top_level.txt

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

agent_as_model-0.1.0/pyproject.toml

@@ -0,0 +1,30 @@
+[project]
+name = "agent-as-model"
+version = "0.1.0"
+description = "A true MCP server where the agent is the model and the API key."
+readme = "README.md"
+requires-python = ">=3.10"
+license = { text = "MIT" }
+authors = [{ name = "Fernando Garza" }]
+dependencies = ["mcp>=2,<3"]
+
+[project.scripts]
+agent-as-model = "agent_as_model.server:main"
+
+[project.urls]
+Homepage = "https://github.com/fernandogarzaaa/agent-as-model"
+Repository = "https://github.com/fernandogarzaaa/agent-as-model"
+
+[build-system]
+requires = ["setuptools>=61"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools.packages.find]
+include = ["agent_as_model*"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+
+[tool.ruff]
+line-length = 100
+target-version = "py310"

agent_as_model-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

agent_as_model-0.1.0/tests/test_protocol.py

@@ -0,0 +1,99 @@
+"""Unit tests for the message-translation layer."""
+
+import pytest
+from mcp.types import CreateMessageResult, ImageContent, TextContent
+
+from agent_as_model.protocol import (
+    AnthropicContentBlock,
+    AnthropicMessage,
+    ChatMessage,
+    anthropic_to_sampling,
+    extract_text,
+    openai_to_sampling,
+)
+
+
+def test_openai_system_messages_become_system_prompt():
+    system_prompt, sampling = openai_to_sampling(
+        [
+            ChatMessage(role="system", content="You are terse."),
+            ChatMessage(role="user", content="Hi"),
+            ChatMessage(role="system", content="No emojis."),
+            ChatMessage(role="assistant", content="Hello"),
+        ]
+    )
+    assert system_prompt == "You are terse.\n\nNo emojis."
+    assert [(m.role, m.content.text) for m in sampling] == [
+        ("user", "Hi"),
+        ("assistant", "Hello"),
+    ]
+
+
+def test_openai_without_system_gives_none_prompt():
+    system_prompt, sampling = openai_to_sampling([ChatMessage(role="user", content="Hi")])
+    assert system_prompt is None
+    assert len(sampling) == 1
+
+
+def test_openai_empty_messages_rejected():
+    with pytest.raises(ValueError, match="non-empty"):
+        openai_to_sampling([])
+
+
+def test_anthropic_text_blocks_and_system_blocks():
+    system_prompt, sampling = anthropic_to_sampling(
+        [
+            AnthropicMessage(
+                role="user",
+                content=[
+                    AnthropicContentBlock(type="text", text="First."),
+                    AnthropicContentBlock(type="text", text="Second."),
+                ],
+            )
+        ],
+        system=[
+            AnthropicContentBlock(type="text", text="Be brief."),
+            AnthropicContentBlock(type="text", text="Be kind."),
+        ],
+    )
+    assert system_prompt == "Be brief.\nBe kind."
+    assert sampling[0].content.text == "First.\nSecond."
+
+
+def test_anthropic_plain_strings():
+    system_prompt, sampling = anthropic_to_sampling(
+        [AnthropicMessage(role="user", content="Hello")], system="Shout."
+    )
+    assert system_prompt == "Shout."
+    assert sampling[0].content.text == "Hello"
+
+
+def test_anthropic_no_system():
+    system_prompt, _ = anthropic_to_sampling([AnthropicMessage(role="user", content="Hello")], None)
+    assert system_prompt is None
+
+
+def test_anthropic_empty_messages_rejected():
+    with pytest.raises(ValueError, match="non-empty"):
+        anthropic_to_sampling([], None)
+
+
+def test_extract_text_returns_text():
+    result = CreateMessageResult(
+        role="assistant",
+        content=TextContent(type="text", text="done"),
+        model="m",
+        stop_reason="endTurn",
+    )
+    assert extract_text(result) == "done"
+
+
+def test_extract_text_rejects_non_text():
+    result = CreateMessageResult(
+        role="assistant",
+        content=ImageContent(type="image", data="eA==", mime_type="image/png"),
+        model="m",
+        stop_reason="endTurn",
+    )
+    with pytest.raises(ValueError, match="text completions only"):
+        extract_text(result)

agent_as_model-0.1.0/tests/test_server.py

@@ -0,0 +1,167 @@
+"""End-to-end tests: an in-process MCP client drives the real server tools.
+
+The scripted sampling callback stands in for the host agent's own model, so
+these tests exercise the full loop a real platform install would run:
+tools/call -> sampling request -> canned host completion -> tool result.
+Both protocol eras are covered: the default (2026-07-28, multi-round-trip)
+and legacy (direct sampling/createMessage).
+"""
+
+from __future__ import annotations
+
+import json
+
+import anyio
+import pytest
+from mcp import types
+from mcp.client import Client
+from mcp.client.session import ClientRequestContext
+
+import agent_as_model.server as agent_server
+
+SERVER = agent_server.mcp
+
+
+def _run(fn):
+    return anyio.run(fn)
+
+
+async def _canned_sampler(
+    context: ClientRequestContext, params: types.CreateMessageRequestParams
+) -> types.CreateMessageResult:
+    """Stand in for the host agent: echo the wire params as the completion."""
+    seen = {
+        "system_prompt": params.system_prompt,
+        "max_tokens": params.max_tokens,
+        "temperature": params.temperature,
+        "messages": [(m.role, m.content.text) for m in params.messages],
+        "hints": [h.name for h in params.model_preferences.hints]
+        if params.model_preferences and params.model_preferences.hints
+        else [],
+    }
+    return types.CreateMessageResult(
+        role="assistant",
+        content=types.TextContent(type="text", text="CANNED:" + json.dumps(seen, sort_keys=True)),
+        model="test-host-model",
+        stop_reason="endTurn",
+    )
+
+
+def _tool_text(result) -> str:
+    assert len(result.content) == 1
+    block = result.content[0]
+    assert block.type == "text"
+    return block.text
+
+
+def test_tools_listed_and_resolve_param_hidden():
+    async def go():
+        async with Client(SERVER) as client:
+            tools = await client.list_tools()
+            names = {t.name for t in tools.tools}
+            assert {"chat_complete", "messages_create", "list_models"} <= names
+            for name in ("chat_complete", "messages_create"):
+                tool = next(t for t in tools.tools if t.name == name)
+                assert "completion" not in tool.input_schema.get("properties", {})
+
+    _run(go)
+
+
+def test_chat_complete_modern_era():
+    async def go():
+        async with Client(SERVER, sampling_callback=_canned_sampler) as client:
+            result = await client.call_tool(
+                "chat_complete",
+                {
+                    "messages": [
+                        {"role": "system", "content": "You are terse."},
+                        {"role": "user", "content": "Say hi."},
+                    ],
+                    "model": "agent-default",
+                    "temperature": 0.5,
+                    "max_tokens": 100,
+                },
+            )
+            seen = json.loads(_tool_text(result).removeprefix("CANNED:"))
+            assert seen["system_prompt"] == "You are terse."
+            assert seen["messages"] == [["user", "Say hi."]]
+            assert seen["max_tokens"] == 100
+            assert seen["temperature"] == 0.5
+            assert seen["hints"] == ["agent-default"]
+
+    _run(go)
+
+
+def test_chat_complete_legacy_era():
+    async def go():
+        async with Client(SERVER, mode="legacy", sampling_callback=_canned_sampler) as client:
+            result = await client.call_tool(
+                "chat_complete",
+                {"messages": [{"role": "user", "content": "Ping"}]},
+            )
+            seen = json.loads(_tool_text(result).removeprefix("CANNED:"))
+            assert seen["messages"] == [["user", "Ping"]]
+            assert seen["system_prompt"] is None
+
+    _run(go)
+
+
+def test_messages_create_anthropic_shape():
+    async def go():
+        async with Client(SERVER, sampling_callback=_canned_sampler) as client:
+            result = await client.call_tool(
+                "messages_create",
+                {
+                    "model": "agent-default",
+                    "system": "Be brief.",
+                    "messages": [{"role": "user", "content": "Summarize this."}],
+                    "max_tokens": 50,
+                },
+            )
+            seen = json.loads(_tool_text(result).removeprefix("CANNED:"))
+            assert seen["system_prompt"] == "Be brief."
+            assert seen["messages"] == [["user", "Summarize this."]]
+
+    _run(go)
+
+
+def test_list_models():
+    async def go():
+        async with Client(SERVER) as client:
+            result = await client.call_tool("list_models", {})
+            models = json.loads(_tool_text(result))
+            assert models[0]["id"] == "agent-default"
+
+    _run(go)
+
+
+def test_default_max_tokens_reaches_host():
+    async def go():
+        async with Client(SERVER, sampling_callback=_canned_sampler) as client:
+            for tool_name, args in (
+                ("chat_complete", {"messages": [{"role": "user", "content": "Hi"}]}),
+                ("messages_create", {"messages": [{"role": "user", "content": "Hi"}]}),
+            ):
+                result = await client.call_tool(tool_name, args)
+                seen = json.loads(_tool_text(result).removeprefix("CANNED:"))
+                assert seen["max_tokens"] == 4096
+
+    _run(go)
+
+
+def test_main_runs_stdio(monkeypatch):
+    calls = []
+    monkeypatch.setattr(SERVER, "run_stdio_async", lambda: calls.append(True))
+    agent_server.main()
+    assert calls == [True]
+
+
+def test_missing_sampling_capability_fails_clearly():
+    async def go():
+        async with Client(SERVER) as client:  # no sampling_callback
+            with pytest.raises(Exception, match="(?i)sampling"):
+                await client.call_tool(
+                    "chat_complete", {"messages": [{"role": "user", "content": "Hi"}]}
+                )
+
+    _run(go)