AutoGen (AG2) + Signbee: Multi-Agent Contract Negotiation & E-Signing (2026)

import os
from typing import Annotated
import httpx
from autogen import ConversableAgent, GroupChat, GroupChatManager, register_function

LLM_CONFIG = {
    "config_list": [{"model": "gpt-4o", "api_key": os.environ["OPENAI_API_KEY"]}],
    "temperature": 0.1,
}


# 1. Define the Signbee E-Signature Dispatch Tool
def dispatch_signbee_contract(
    title: Annotated[str, "Official agreement title displayed on the SHA-256 certificate"],
    markdown: Annotated[str, "Complete, compliance-approved CommonMark Markdown contract"],
    recipient_name: Annotated[str, "Full legal name of Party B counterparty"],
    recipient_email: Annotated[str, "Verified email address of Party B counterparty"],
    expires_in_days: Annotated[int, "Days until signing link expires (default 14)"] = 14,
) -> str:
    """
    Compiles a CommonMark Markdown contract into an A4 PDF, binds Party A via API key,
    and emails Party B an interactive signing ceremony link via Signbee REST API v1.
    """
    api_key = os.environ["SIGNBEE_API_KEY"]
    with httpx.Client(timeout=20.0) as client:
        response = client.post(
            "https://signb.ee/api/v1/send",
            headers={
                "Authorization": f"Bearer {api_key}",
                "Content-Type": "application/json",
            },
            json={
                "title": title,
                "markdown": markdown,
                "sender_name": "Michael Beckett",
                "sender_email": "michael@signb.ee",
                "recipient_name": recipient_name,
                "recipient_email": recipient_email,
                "expires_in_days": expires_in_days,
            },
        )
        response.raise_for_status()
        data = response.json()
        doc_id = data["id"]
        return (
            f"CONTRACT_DISPATCHED_SUCCESS | Document ID: {doc_id} | "
            f"Status: {data.get('status', 'PENDING')} | "
            f"Verify SHA-256 URL: https://signb.ee/verify/{doc_id}"
        )


# 2. Agent 1: Commercial Terms Drafter (No Tool Execution Privileges)
commercial_drafter = ConversableAgent(
    name="commercial_drafter",
    system_prompt=(
        "You are the Commercial Deal Structuring Agent. Draft clear, comprehensive CommonMark "
        "Markdown agreements including a GitHub Flavored Markdown milestone fee table. "
        "Incorporate all redlines requested by legal_reviewer until approved."
    ),
    llm_config=LLM_CONFIG,
    human_input_mode="NEVER",
)


# 3. Agent 2: Adversarial Legal Risk & Compliance Reviewer (Proposes Tool Call Only When Compliant)
legal_reviewer = ConversableAgent(
    name="legal_reviewer",
    system_prompt=(
        "You are General Counsel & Compliance Reviewer. Audit every contract draft from "
        "commercial_drafter against three mandatory rules:\n"
        "1. Limitation of Liability MUST be capped at 100% of fees paid under this agreement.\n"
        "2. Intellectual Property transfer MUST be explicitly contingent upon full payment.\n"
        "3. Governing Law MUST be explicitly set to England and Wales or State of Delaware.\n"
        "If ANY rule is missing or ambiguous, reply with specific redline instructions and "
        "DO NOT call any tool. Only when all 3 rules and fee math are verified, call "
        "dispatch_signbee_contract with the complete CommonMark text."
    ),
    llm_config=LLM_CONFIG,
    human_input_mode="NEVER",
)


# 4. Agent 3: Deal Desk Execution Proxy (Executes Signbee Tool Call & Halts Loop)
deal_desk_executor = ConversableAgent(
    name="deal_desk_executor",
    llm_config=False,
    # Set to "ALWAYS" in interactive CLI to require human sign-off before HTTP POST
    human_input_mode="NEVER",
    is_termination_msg=lambda msg: "CONTRACT_DISPATCHED_SUCCESS" in (msg.get("content") or ""),
)


# 5. Bind Tool Schema to Legal Reviewer and Execution Runtime to Deal Desk Executor
register_function(
    dispatch_signbee_contract,
    caller=legal_reviewer,
    executor=deal_desk_executor,
    name="dispatch_signbee_contract",
    description="Dispatch a compliance-approved CommonMark contract for e-signature via Signbee.",
)

def deal_desk_speaker_transitions(last_speaker: ConversableAgent, groupchat: GroupChat):
    messages = groupchat.messages
    last_msg = messages[-1] if messages else {}

    if last_speaker is deal_desk_executor:
        # Initial prompt -> route to Commercial Drafter; after execution -> terminate
        if "CONTRACT_DISPATCHED_SUCCESS" in (last_msg.get("content") or ""):
            return None
        return commercial_drafter

    if last_speaker is commercial_drafter:
        # Every commercial draft MUST be audited by Legal Reviewer
        return legal_reviewer

    if last_speaker is legal_reviewer:
        # If Legal Reviewer approved and emitted tool_calls, route to Deal Desk Executor
        if "tool_calls" in last_msg and last_msg["tool_calls"]:
            return deal_desk_executor
        # Otherwise, route redline feedback back to Commercial Drafter
        return commercial_drafter

    return None


group_chat = GroupChat(
    agents=[deal_desk_executor, commercial_drafter, legal_reviewer],
    messages=[],
    max_round=8,
    speaker_selection_method=deal_desk_speaker_transitions,
)

manager = GroupChatManager(groupchat=group_chat, llm_config=LLM_CONFIG)

if __name__ == "__main__":
    deal_desk_executor.initiate_chat(
        manager,
        message=(
            "Draft and dispatch a Statement of Work for Horizon Robotics Ltd "
            "(Recipient: Clara Oswald, clara@horizonrobotics.co.uk). "
            "Milestone 1: Autonomous Perception Audit ($14,000, due 2026-10-15). "
            "Milestone 2: Production Edge Deployment ($22,000, due 2026-11-15). "
            "Governing Law: England and Wales."
        ),
    )

import asyncio
import os
from mcp import ClientSession, StdioServerParameters
from mcp.client.stdio import stdio_client
from autogen.mcp import create_toolkit

async def run_autogen_with_signbee_mcp():
    server_params = StdioServerParameters(
        command="npx",
        args=["-y", "signbee-mcp"],
        env={"SIGNBEE_API_KEY": os.environ["SIGNBEE_API_KEY"]},
    )

    async with stdio_client(server_params) as (read, write):
        async with ClientSession(read, write) as session:
            await session.initialize()
            toolkit = await create_toolkit(session=session)

            # Register send_document & get_document_status tools onto your AG2 agents
            toolkit.register_for_llm(legal_reviewer)
            toolkit.register_for_execution(deal_desk_executor)

            print("Registered MCP Tools:", [t.name for t in toolkit.tools])

if __name__ == "__main__":
    asyncio.run(run_autogen_with_signbee_mcp())