Not exactly one page but here is what I would consider a minimal harness with search, fileio, and url reading:

https://pastebin.com/pPLjbqqa

Optional command line arguments:

--llama_server LLM server URL. Defaults to http://localhost:8080.

--prompt_file File containing the initial user prompt.

--system_prompt File containing the system prompt. Replaces default.

--working_dir Base directory for file operations. Defaults to current directory.

--exit Terminate program after processing --prompt_file.

Hopefully the chat loop and whats going on with tools is still simple enough to still understand fully. This is obviously all vibe coded with minimal testing so take that for what its worth.

It's about as simple as I could make it with a chat loop that switches to responding to tool results but I would immediately change how the tool parameters are handled. I would not get a tool specific parameter in the chat loop but instead I would pass the entire parameter object to the tool function as well as other things a tool might need like a cancel event object, limits to the amount of data the tool should return etc:

import os
import asyncio
import urllib.request
import urllib.error
import socket
import ssl
import re

class URLFetch:
    def __init__(self, *args, **kwargs):
        pass

    def spec(self):
        return {
            "type": "function",
            "function": {
                "name": "urlfetch",
                "description": "Fetch data from a URL. Optionally save to a file.",
                "parameters": {
                    "type": "object",
                    "properties": {
                        "url": {
                            "type": "string",
                            "description": "The URL to fetch data from."
                        },
                        "save_to_file": {
                            "type": "string",
                            "description": "Optional path to save the fetched data. If not provided, data is returned."
                        },
                        "timeout": {
                            "type": "number",
                            "description": "Timeout in seconds for the request. Defaults to 60."
                        }
                    },
                    "required": ["url"]
                },
            },
        }

    def _is_within_directory(self, directory, target_path):
        abs_directory = os.path.abspath(directory)
        abs_target = os.path.abspath(target_path)
        return abs_target.startswith(abs_directory + os.sep) or abs_target == abs_directory

    async def run(self, *args, **kwargs):
        arguments = kwargs.get('arguments', args[0] if args else {})
        stop_event = kwargs.get('stop_event', asyncio.Event())
        byte_limit = kwargs.get('byte_limit', None)
        working_directory = kwargs.get('working_directory', None)

        url = arguments.get('url')
        save_to_file = arguments.get('save_to_file')
        timeout = arguments.get('timeout', 60)

        if not url:
            return "Error: URL is required."

        original_timeout = socket.getdefaulttimeout()
        socket.setdefaulttimeout(timeout)

        try:
            loop = asyncio.get_event_loop()

            def fetch_data():
                try:
                    parsed_url = url
                    extra_headers = {}

                    if 'imgur.com' in url:
                        match = re.search(r'(?:i\.)?imgur\.com/([a-zA-Z0-9]+)', url)
                        if match:
                            image_hash = match.group(1).split('.')[0]
                            parsed_url = f"https://i.imgur.com/{image_hash}.png"
                            extra_headers = {
                                "Referer": "https://imgur.com/",
                                "Origin": "https://imgur.com"
                            }

                    headers = {
                        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
                        "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8",
                        "Accept-Language": "en-US,en;q=0.9",
                        "Accept-Encoding": "gzip, deflate, br",
                        "Connection": "keep-alive",
                        "Upgrade-Insecure-Requests": "1",
                        "Sec-Fetch-Dest": "document",
                        "Sec-Fetch-Mode": "navigate",
                        "Sec-Fetch-Site": "none",
                        "Sec-Fetch-User": "?1",
                        "Cache-Control": "max-age=0",
                    }
                    headers.update(extra_headers)

                    req = urllib.request.Request(parsed_url, headers=headers)

                    ssl_context = ssl.create_default_context()
                    ssl_context.check_hostname = True
                    ssl_context.verify_mode = ssl.CERT_REQUIRED

                    with urllib.request.urlopen(req, context=ssl_context, timeout=timeout) as response:
                        chunk_size = 8192
                        data_chunks = []
                        while True:
                            if stop_event.is_set():
                                raise asyncio.CancelledError("Request cancelled by user.")
                            chunk = response.read(chunk_size)
                            if not chunk:
                                break
                            data_chunks.append(chunk)
                        return b''.join(data_chunks)
                except urllib.error.URLError as e:
                    return f"Error fetching URL: {e.reason}"
                except Exception as e:
                    return f"Error fetching URL: {str(e)}"

            try:
                data_or_error = await loop.run_in_executor(None, fetch_data)
            except asyncio.CancelledError:
                return "Request cancelled by user."
            except Exception as e:
                return f"Error during fetch: {str(e)}"

            if isinstance(data_or_error, str) and data_or_error.startswith("Error"):
                return data_or_error

            data = data_or_error

        except Exception as e:
            return f"Error fetching URL: {str(e)}"
        finally:
            socket.setdefaulttimeout(original_timeout)

        if save_to_file:
            if working_directory:
                save_to_file = os.path.join(working_directory, save_to_file)
                if not self._is_within_directory(working_directory, save_to_file):
                    return f"Error: Save path '{save_to_file}' is outside the working directory."
            try:
                with open(save_to_file, 'wb') as f:
                    f.write(data)
                return f"Successfully saved data to {save_to_file} ({len(data)} bytes)"
            except Exception as e:
                return f"Error saving to file: {str(e)}"
        else:
            if byte_limit is not None and len(data) > byte_limit:
                return f"Error: Data size ({len(data)} bytes) exceeds byte limit ({byte_limit} bytes)."
            try:
                return data.decode('utf-8', errors='replace')
            except Exception as e:
                return f"Error decoding data: {str(e)}"

As you add more complexity the surface area for bugs and for more features also expands and sometimes that might mean overhauling the entire thing. I have started to look at other harnesses and notice a lot of them build the tools themselves as state machines so for example a file io tool might have an option to set the path and then the next time the tool is called it is still in that path where as with my tool it has to specify the full path each time. With file io thats fine but models are getting good enough that if you give them a python sandbox they will try to run scripts and then interact with the running script they made so having some way to store the id of running scripts and to get new console output enter new input means the bot can test things like building webservers and testing their APIs. Qwen 27b is good enough for all that but it also means properly sandboxing everything becomes a priority.