Agent Skills

import Anthropic from "@anthropic-ai/sdk";

const client = new Anthropic();

const tools: Anthropic.Tool[] = [
  {
    name: "verify_email",
    description: `Überprüfe, ob eine E-Mail-Adresse gültig und zustellbar ist.

Rückgabewerte:
- status: "valid", "invalid" oder "unknown"
- deliverable: ob die E-Mail Nachrichten empfangen kann
- disposable: ob es ein temporärer E-Mail-Dienst ist
- role: ob es eine rollenbasierte Adresse ist (info@, support@)
- score: Konfidenzwert von 0 bis 1`,
    input_schema: {
      type: "object",
      properties: {
        email: {
          type: "string",
          description: "Die zu verifizierende E-Mail-Adresse",
        },
      },
      required: ["email"],
    },
  },
];

async function verifyEmail(email: string) {
  const response = await fetch("https://api.emailverify.ai/v1/verify", {
    method: "POST",
    headers: {
      Authorization: `Bearer ${process.env.EMAILVERIFY_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({ email }),
  });
  return response.json();
}

async function processToolCall(
  toolName: string,
  toolInput: Record<string, string>
) {
  if (toolName === "verify_email") {
    return await verifyEmail(toolInput.email);
  }
  throw new Error(`Unknown tool: ${toolName}`);
}

async function agentLoop(userMessage: string) {
  const messages: Anthropic.MessageParam[] = [
    { role: "user", content: userMessage },
  ];

  while (true) {
    const response = await client.messages.create({
      model: "claude-sonnet-4-20250514",
      max_tokens: 4096,
      tools,
      messages,
    });

    // Check if we need to process tool calls
    if (response.stop_reason === "tool_use") {
      const toolUseBlocks = response.content.filter(
        (block): block is Anthropic.ToolUseBlock => block.type === "tool_use"
      );

      const toolResults: Anthropic.ToolResultBlockParam[] = [];

      for (const toolUse of toolUseBlocks) {
        const result = await processToolCall(
          toolUse.name,
          toolUse.input as Record<string, string>
        );
        toolResults.push({
          type: "tool_result",
          tool_use_id: toolUse.id,
          content: JSON.stringify(result),
        });
      }

      messages.push({ role: "assistant", content: response.content });
      messages.push({ role: "user", content: toolResults });
    } else {
      // Agent is done
      const textBlock = response.content.find(
        (block): block is Anthropic.TextBlock => block.type === "text"
      );
      return textBlock?.text;
    }
  }
}

// Nutzung
const result = await agentLoop(
  "Ich habe eine Liste von E-Mails zu verifizieren: john@google.com, test@mailinator.com, support@microsoft.com. Prüfe jede einzelne und sage mir, welche sicher zu verwenden sind."
);
console.log(result);

from crewai import Agent, Task, Crew
from crewai_tools import tool
import requests
import os

@tool("Email Verification Tool")
def verify_email(email: str) -> str:
    """Überprüfe, ob eine E-Mail-Adresse gültig und zustellbar ist.

    Args:
        email: Die zu verifizierende E-Mail-Adresse

    Returns:
        Verifizierungsergebnis mit Status, Zustellbarkeit und Risiko-Flags
    """
    response = requests.post(
        'https://api.emailverify.ai/v1/verify',
        headers={
            'Authorization': f'Bearer {os.environ["EMAILVERIFY_API_KEY"]}',
            'Content-Type': 'application/json',
        },
        json={'email': email}
    )
    result = response.json()
    return f"Email: {email}, Status: {result['status']}, Score: {result['score']}"

# Erstelle einen Agenten mit der Verifizierungs-Fähigkeit
data_quality_agent = Agent(
    role='Datenqualitäts-Spezialist',
    goal='Sicherstellen, dass alle E-Mail-Adressen in der Datenbank gültig und zustellbar sind',
    backstory='Experte für Datenvalidierung und E-Mail-Zustellbarkeit',
    tools=[verify_email],
    verbose=True
)

# Erstelle eine Aufgabe
verification_task = Task(
    description='Verifiziere die folgenden E-Mail-Adressen und berichte, welche ungültig sind: {emails}',
    expected_output='Ein Bericht aller E-Mails mit ihrem Verifizierungsstatus',
    agent=data_quality_agent
)

# Führe die Crew aus
crew = Crew(
    agents=[data_quality_agent],
    tasks=[verification_task]
)

result = crew.kickoff(inputs={
    'emails': 'john@google.com, fake@invalid.xyz, test@mailinator.com'
})
print(result)

# autogpt_plugins/emailverify/__init__.py
from typing import Any, Dict, List, Optional, Tuple, TypeVar
import requests
import os

PromptGenerator = TypeVar("PromptGenerator")

class EmailVerifyPlugin:
    def __init__(self):
        self.api_key = os.environ.get("EMAILVERIFY_API_KEY")

    @staticmethod
    def get_name() -> str:
        return "EmailVerify E-Mail-Verifizierung"

    def can_handle_post_prompt(self) -> bool:
        return True

    def post_prompt(self, prompt: PromptGenerator) -> PromptGenerator:
        prompt.add_command(
            "verify_email",
            "Überprüfe, ob eine E-Mail gültig ist",
            {"email": "<email_address>"},
            self.verify_email
        )
        return prompt

    def verify_email(self, email: str) -> str:
        response = requests.post(
            'https://api.emailverify.ai/v1/verify',
            headers={
                'Authorization': f'Bearer {self.api_key}',
                'Content-Type': 'application/json',
            },
            json={'email': email}
        )
        result = response.json()

        if result['status'] == 'valid':
            return f"✅ {email} ist gültig (Score: {result['score']})"
        elif result['status'] == 'invalid':
            return f"❌ {email} ist ungültig"
        else:
            return f"⚠️ {email} Status unbekannt"

description: `Überprüfe, ob eine E-Mail-Adresse gültig und zustellbar ist.

Verwende diesen Skill, wenn:
- Benutzer bittet, eine E-Mail-Adresse zu prüfen
- Kontaktinformationen vor dem Speichern validiert werden
- E-Mail-Listen bereinigt werden
- Geprüft wird, ob eine E-Mail Wegwerf oder rollenbasiert ist

Rückgabewerte: Status, Zustellbarkeit, Wegwerf-Flag, Rollen-Flag, Konfidenzwert`

@tool("E-Mail-Verifizierung")
def verify_email(email: str) -> str:
    try:
        response = requests.post(
            'https://api.emailverify.ai/v1/verify',
            headers={
                'Authorization': f'Bearer {os.environ["EMAILVERIFY_API_KEY"]}',
                'Content-Type': 'application/json',
            },
            json={'email': email},
            timeout=30
        )

        if response.status_code == 429:
            return "Rate Limit überschritten. Bitte versuchen Sie es später erneut."

        response.raise_for_status()
        return response.json()

    except requests.exceptions.Timeout:
        return "Verifizierung hat Zeitüberschreitung. Bitte versuchen Sie es erneut."
    except Exception as e:
        return f"Verifizierung fehlgeschlagen: {str(e)}"

const verifyBulkSkill = {
  name: "verify_emails_bulk",
  description: "Mehrere E-Mail-Adressen auf einmal verifizieren. Effizienter für Listen.",
  input_schema: {
    type: "object",
    properties: {
      emails: {
        type: "array",
        items: { type: "string" },
        description: "Array von zu verifizierenden E-Mails (max 100)",
      },
    },
    required: ["emails"],
  },
};