AI Agent Integration

// ~/Library/Application Support/Claude/claude_desktop_config.json
{
  "mcpServers": {
    "fce-mcp": {
      "command": "npx",
      "args": ["-y", "fce-mcp-server"],
      "env": {
        "FCE_API_KEY": "fce_your_growth_api_key"
      }
    }
  }
}

import os
from langchain.tools import tool
from langchain_openai import ChatOpenAI
from langchain.agents import create_tool_calling_agent, AgentExecutor
from langchain_core.prompts import ChatPromptTemplate
from freecustom_email import FreeCustomEmail

fce = FreeCustomEmail(api_key=os.environ['FCE_API_KEY'], sync=True)

@tool
def create_inbox_and_wait_for_otp(domain: str = "ditapi.info", timeout: int = 45) -> dict:
    """
    Creates a disposable email inbox and waits up to `timeout` seconds for
    an OTP email to arrive. Returns the inbox address and OTP.
    """
    import time
    inbox = f"agent-{int(time.time())}@{domain}"
    fce.inboxes.register(inbox)
    
    # We yield control, letting the agent trigger signup, but for this demo tool
    # we assume the signup is triggered externally or we wait immediately.
    # In a real agent, you would split this into `create_inbox` and `wait_for_otp` tools.
    otp = fce.otp.wait_for(inbox, timeout_ms=timeout * 1000)
    return {"inbox": inbox, "otp": otp}

@tool
def get_otp_for_inbox(inbox: str) -> str:
    """Extracts the most recent OTP from an already-registered inbox."""
    return fce.otp.wait_for(inbox, timeout_ms=30000)

llm = ChatOpenAI(model="gpt-4o")
tools = [create_inbox_and_wait_for_otp, get_otp_for_inbox]

prompt = ChatPromptTemplate.from_messages([
    ("system", "You are an automation agent. Use the tools to handle email verification."),
    ("human", "{input}"),
    ("placeholder", "{agent_scratchpad}"),
])

agent = create_tool_calling_agent(llm, tools, prompt)
executor = AgentExecutor(agent=agent, tools=tools, verbose=True)

result = executor.invoke({
    "input": "Create a disposable inbox, sign up at demo.acme.com, and return the OTP."
})
print(result["output"])

from langgraph.graph import StateGraph, END
from typing import TypedDict
import os, time
from freecustom_email import FreeCustomEmail

fce = FreeCustomEmail(api_key=os.environ['FCE_API_KEY'], sync=True)

class State(TypedDict):
    url: str
    inbox: str | None
    otp: str | None
    verified: bool

def provision_email_and_wait(state: State) -> State:
    """LangGraph node: create inbox + wait for OTP."""
    inbox = f"graph-{int(time.time())}@ditapi.info"
    fce.inboxes.register(inbox)
    
    # Ideally, trigger your app's signup request here before waiting
    otp = fce.otp.wait_for(inbox, timeout_ms=45000)
    
    return {**state, "inbox": inbox, "otp": otp}

def verify_account(state: State) -> State:
    # Your verification logic here using the extracted OTP
    print(f"Verifying with OTP: {state['otp']} for {state['inbox']}")
    return {**state, "verified": True}

graph = StateGraph(State)
graph.add_node("provision_email", provision_email_and_wait)
graph.add_node("verify_account", verify_account)
graph.set_entry_point("provision_email")
graph.add_edge("provision_email", "verify_account")
graph.add_edge("verify_account", END)

app = graph.compile()
result = app.invoke({"url": "https://acme.com", "inbox": None, "otp": None, "verified": False})
print(result)

import json, os, time
from openai import OpenAI
from freecustom_email import FreeCustomEmail

client = OpenAI()
fce = FreeCustomEmail(api_key=os.environ['FCE_API_KEY'], sync=True)

tools = [
    {
        "type": "function",
        "function": {
            "name": "create_inbox_and_wait_for_otp",
            "description": "Creates a disposable inbox and waits for an OTP email.",
            "parameters": {
                "type": "object",
                "properties": {
                    "timeout": {"type": "integer", "description": "Max seconds to wait (10-60)"},
                },
            },
        },
    }
]

def call_fce(name: str, args: dict) -> str:
    if name == "create_inbox_and_wait_for_otp":
        inbox = f"ai-{int(time.time())}@ditapi.info"
        fce.inboxes.register(inbox)
        
        # Note: In a real flow, you'd tell the LLM the inbox first, let it
        # sign up, and then call a separate wait_for_otp tool.
        otp = fce.otp.wait_for(inbox, timeout_ms=args.get("timeout", 45) * 1000)
        return json.dumps({"inbox": inbox, "otp": otp})
    return json.dumps({"error": "unknown tool"})

messages = [{"role": "user", "content": "Create a disposable inbox and give me the OTP."}]

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

if msg.tool_calls:
    for tc in msg.tool_calls:
        result = call_fce(tc.function.name, json.loads(tc.function.arguments))
        messages.extend([
            msg,
            {"role": "tool", "tool_call_id": tc.id, "content": result},
        ])
    
    final = client.chat.completions.create(model="gpt-4o", messages=messages)
    print(final.choices[0].message.content)

{
  "mcpServers": {
    "fce-mcp": {
      "command": "npx",
      "args": ["-y", "fce-mcp-server"],
      "env": { "FCE_API_KEY": "fce_your_growth_api_key" }
    }
  }
}