AgentGen + OpenAI Function Calling

OpenAI's function calling (tool calling) lets GPT-4o decide when to invoke external APIs. Define AgentGen's PDF and image endpoints as tools, and your GPT-4o agent will produce downloadable documents as a natural part of any conversation.

Install

pip install openai requests python-dotenv

Step 1 — Define the tool schemas

tools = [
    {
        "type": "function",
        "function": {
            "name": "generate_pdf",
            "description": (
                "Render an HTML document to a PDF and return a CDN download URL. "
                "Cost: 2 tokens per page. Use for invoices, reports, certificates."
            ),
            "parameters": {
                "type": "object",
                "properties": {
                    "html": {
                        "type": "string",
                        "description": "Complete HTML document to render as PDF",
                    },
                    "page_size": {
                        "type": "string",
                        "enum": ["A4", "Letter", "A3", "Legal"],
                        "default": "A4",
                    },
                },
                "required": ["html"],
            },
        },
    },
    {
        "type": "function",
        "function": {
            "name": "generate_image",
            "description": (
                "Render HTML to a PNG, JPEG, or WebP image and return a CDN URL. "
                "Cost: 1 token. Use for OG images, thumbnails, screenshots."
            ),
            "parameters": {
                "type": "object",
                "properties": {
                    "html": {"type": "string", "description": "HTML to render as image"},
                    "width": {"type": "integer", "default": 1200},
                    "height": {"type": "integer", "default": 630},
                    "format": {"type": "string", "enum": ["png", "jpeg", "webp"], "default": "png"},
                },
                "required": ["html"],
            },
        },
    },
]

Step 2 — Implement the tool handlers

import os, json, requests

AGENTGEN_KEY = os.environ["AGENTGEN_API_KEY"]

def handle_tool_call(name: str, arguments: str) -> str:
    args = json.loads(arguments)
    if name == "generate_pdf":
        r = requests.post(
            "https://www.agent-gen.com/api/v1/generate/pdf",
            headers={"X-API-Key": AGENTGEN_KEY, "Content-Type": "application/json"},
            json={"html": args["html"], "format": args.get("format", "A4")},
            timeout=30,
        )
    elif name == "generate_image":
        r = requests.post(
            "https://www.agent-gen.com/api/v1/generate/image",
            headers={"X-API-Key": AGENTGEN_KEY, "Content-Type": "application/json"},
            json={
                "html": args["html"],
                "width": args.get("width", 1200),
                "height": args.get("height", 630),
                "format": args.get("format", "png"),
            },
            timeout=30,
        )
    else:
        return json.dumps({"error": f"Unknown tool: {name}"})

    if r.status_code == 402:
        return json.dumps({"error": "Insufficient tokens. Visit agent-gen.com/pricing."})
    r.raise_for_status()
    return json.dumps(r.json())

Step 3 — The agent loop

from openai import OpenAI

client = OpenAI()

def run_agent(user_message: str) -> str:
    messages = [
        {
            "role": "system",
            "content": (
                "You are a helpful assistant that can generate PDFs and images. "
                "When a user asks for a document or image, write clean HTML with "
                "inline styles and call the appropriate tool."
            ),
        },
        {"role": "user", "content": user_message},
    ]

    while True:
        response = client.chat.completions.create(
            model="gpt-4o",
            messages=messages,
            tools=tools,
            tool_choice="auto",
        )
        msg = response.choices[0].message

        if msg.tool_calls:
            messages.append(msg)
            for call in msg.tool_calls:
                result = handle_tool_call(call.function.name, call.function.arguments)
                messages.append({
                    "role": "tool",
                    "tool_call_id": call.id,
                    "content": result,
                })
        else:
            return msg.content

# Run it
print(run_agent("Create a PDF invoice for Acme Corp, $3,500 for API development, due April 1"))
# → "Here's your invoice: https://cdn.agent-gen.com/output/abc123.pdf"

Using with the Assistants API

The same tool definitions work with the OpenAI Assistants API. Create an Assistant with the tools array above, then handle requires_action run statuses the same way:

assistant = client.beta.assistants.create(
    name="Document Generator",
    instructions="Generate professional PDFs and images using the provided tools.",
    model="gpt-4o",
    tools=tools,
)

thread = client.beta.threads.create()
client.beta.threads.messages.create(thread.id, role="user",
    content="Generate a certificate PDF for Alice Smith, Python course, March 2026")

run = client.beta.threads.runs.create_and_poll(
    thread_id=thread.id,
    assistant_id=assistant.id,
)

if run.status == "requires_action":
    tool_outputs = []
    for call in run.required_action.submit_tool_outputs.tool_calls:
        output = handle_tool_call(call.function.name, call.function.arguments)
        tool_outputs.append({"tool_call_id": call.id, "output": output})
    run = client.beta.threads.runs.submit_tool_outputs_and_poll(
        thread_id=thread.id, run_id=run.id, tool_outputs=tool_outputs,
    )