ad83825f93
Updates all classes to use the new modular namespace convention. Adds Service/ layer with Core\Service\Agentic for service definition. Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
441 lines
14 KiB
PHP
441 lines
14 KiB
PHP
<?php
|
|
|
|
declare(strict_types=1);
|
|
|
|
namespace Core\Mod\Agentic\Services;
|
|
|
|
use Core\Mod\Agentic\Models\AgentApiKey;
|
|
use Core\Mod\Agentic\Support\AgentIdentity;
|
|
use Illuminate\Http\Request;
|
|
|
|
/**
|
|
* Service for detecting AI agents from HTTP requests.
|
|
*
|
|
* Identifies AI agent providers (Anthropic, OpenAI, Google, etc.) from:
|
|
* - User-Agent string patterns
|
|
* - MCP token headers
|
|
* - Absence of typical browser indicators
|
|
*
|
|
* Part of the Trees for Agents system for rewarding AI agent referrals.
|
|
*/
|
|
class AgentDetection
|
|
{
|
|
/**
|
|
* User-Agent patterns for known AI providers.
|
|
*
|
|
* @var array<string, array{pattern: string, model_pattern: ?string}>
|
|
*/
|
|
protected const PROVIDER_PATTERNS = [
|
|
'anthropic' => [
|
|
'patterns' => [
|
|
'/claude[\s\-_]?code/i',
|
|
'/\banthopic\b/i',
|
|
'/\banthropic[\s\-_]?api\b/i',
|
|
'/\bclaude\b.*\bai\b/i',
|
|
'/\bclaude\b.*\bassistant\b/i',
|
|
],
|
|
'model_patterns' => [
|
|
'claude-opus' => '/claude[\s\-_]?opus/i',
|
|
'claude-sonnet' => '/claude[\s\-_]?sonnet/i',
|
|
'claude-haiku' => '/claude[\s\-_]?haiku/i',
|
|
],
|
|
],
|
|
'openai' => [
|
|
'patterns' => [
|
|
'/\bChatGPT\b/i',
|
|
'/\bOpenAI\b/i',
|
|
'/\bGPT[\s\-_]?4\b/i',
|
|
'/\bGPT[\s\-_]?3\.?5\b/i',
|
|
'/\bo1[\s\-_]?preview\b/i',
|
|
'/\bo1[\s\-_]?mini\b/i',
|
|
],
|
|
'model_patterns' => [
|
|
'gpt-4' => '/\bGPT[\s\-_]?4/i',
|
|
'gpt-3.5' => '/\bGPT[\s\-_]?3\.?5/i',
|
|
'o1' => '/\bo1[\s\-_]?(preview|mini)?\b/i',
|
|
],
|
|
],
|
|
'google' => [
|
|
'patterns' => [
|
|
'/\bGoogle[\s\-_]?AI\b/i',
|
|
'/\bGemini\b/i',
|
|
'/\bBard\b/i',
|
|
'/\bPaLM\b/i',
|
|
],
|
|
'model_patterns' => [
|
|
'gemini-pro' => '/gemini[\s\-_]?(1\.5[\s\-_]?)?pro/i',
|
|
'gemini-ultra' => '/gemini[\s\-_]?(1\.5[\s\-_]?)?ultra/i',
|
|
'gemini-flash' => '/gemini[\s\-_]?(1\.5[\s\-_]?)?flash/i',
|
|
],
|
|
],
|
|
'meta' => [
|
|
'patterns' => [
|
|
'/\bMeta[\s\-_]?AI\b/i',
|
|
'/\bLLaMA\b/i',
|
|
'/\bLlama[\s\-_]?[23]\b/i',
|
|
],
|
|
'model_patterns' => [
|
|
'llama-3' => '/llama[\s\-_]?3/i',
|
|
'llama-2' => '/llama[\s\-_]?2/i',
|
|
],
|
|
],
|
|
'mistral' => [
|
|
'patterns' => [
|
|
'/\bMistral\b/i',
|
|
'/\bMixtral\b/i',
|
|
],
|
|
'model_patterns' => [
|
|
'mistral-large' => '/mistral[\s\-_]?large/i',
|
|
'mistral-medium' => '/mistral[\s\-_]?medium/i',
|
|
'mixtral' => '/mixtral/i',
|
|
],
|
|
],
|
|
];
|
|
|
|
/**
|
|
* Patterns that indicate a typical web browser.
|
|
* If none of these are present, it might be programmatic access.
|
|
*/
|
|
protected const BROWSER_INDICATORS = [
|
|
'/\bMozilla\b/i',
|
|
'/\bChrome\b/i',
|
|
'/\bSafari\b/i',
|
|
'/\bFirefox\b/i',
|
|
'/\bEdge\b/i',
|
|
'/\bOpera\b/i',
|
|
'/\bMSIE\b/i',
|
|
'/\bTrident\b/i',
|
|
];
|
|
|
|
/**
|
|
* Known bot patterns that are NOT AI agents.
|
|
* These should return notAnAgent, not unknown.
|
|
*/
|
|
protected const NON_AGENT_BOTS = [
|
|
'/\bGooglebot\b/i',
|
|
'/\bBingbot\b/i',
|
|
'/\bYandexBot\b/i',
|
|
'/\bDuckDuckBot\b/i',
|
|
'/\bBaiduspider\b/i',
|
|
'/\bfacebookexternalhit\b/i',
|
|
'/\bTwitterbot\b/i',
|
|
'/\bLinkedInBot\b/i',
|
|
'/\bSlackbot\b/i',
|
|
'/\bDiscordBot\b/i',
|
|
'/\bTelegramBot\b/i',
|
|
'/\bWhatsApp\//i',
|
|
'/\bApplebot\b/i',
|
|
'/\bSEMrushBot\b/i',
|
|
'/\bAhrefsBot\b/i',
|
|
'/\bcurl\b/i',
|
|
'/\bwget\b/i',
|
|
'/\bpython-requests\b/i',
|
|
'/\bgo-http-client\b/i',
|
|
'/\bPostman\b/i',
|
|
'/\bInsomnia\b/i',
|
|
'/\baxios\b/i',
|
|
'/\bnode-fetch\b/i',
|
|
'/\bUptimeRobot\b/i',
|
|
'/\bPingdom\b/i',
|
|
'/\bDatadog\b/i',
|
|
'/\bNewRelic\b/i',
|
|
];
|
|
|
|
/**
|
|
* The MCP token header name.
|
|
*/
|
|
protected const MCP_TOKEN_HEADER = 'X-MCP-Token';
|
|
|
|
/**
|
|
* Identify an agent from an HTTP request.
|
|
*/
|
|
public function identify(Request $request): AgentIdentity
|
|
{
|
|
// First, check for MCP token (highest priority)
|
|
$mcpToken = $request->header(self::MCP_TOKEN_HEADER);
|
|
if ($mcpToken) {
|
|
return $this->identifyFromMcpToken($mcpToken);
|
|
}
|
|
|
|
// Then check User-Agent
|
|
$userAgent = $request->userAgent();
|
|
|
|
return $this->identifyFromUserAgent($userAgent);
|
|
}
|
|
|
|
/**
|
|
* Identify an agent from a User-Agent string.
|
|
*/
|
|
public function identifyFromUserAgent(?string $userAgent): AgentIdentity
|
|
{
|
|
if (! $userAgent || trim($userAgent) === '') {
|
|
// Empty User-Agent is suspicious but not definitive
|
|
return AgentIdentity::unknownAgent();
|
|
}
|
|
|
|
// Check for known AI providers first (highest confidence)
|
|
foreach (self::PROVIDER_PATTERNS as $provider => $config) {
|
|
foreach ($config['patterns'] as $pattern) {
|
|
if (preg_match($pattern, $userAgent)) {
|
|
$model = $this->detectModel($userAgent, $config['model_patterns']);
|
|
|
|
return $this->createProviderIdentity($provider, $model, AgentIdentity::CONFIDENCE_HIGH);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Check for non-agent bots (search engines, monitoring, etc.)
|
|
foreach (self::NON_AGENT_BOTS as $pattern) {
|
|
if (preg_match($pattern, $userAgent)) {
|
|
return AgentIdentity::notAnAgent();
|
|
}
|
|
}
|
|
|
|
// Check if it looks like a normal browser
|
|
if ($this->looksLikeBrowser($userAgent)) {
|
|
return AgentIdentity::notAnAgent();
|
|
}
|
|
|
|
// No browser indicators and not a known bot — might be an unknown agent
|
|
return AgentIdentity::unknownAgent();
|
|
}
|
|
|
|
/**
|
|
* Identify an agent from an MCP token.
|
|
*
|
|
* MCP tokens can encode provider and model information for registered agents.
|
|
* Supports two token formats:
|
|
* - Structured: "provider:model:secret" (e.g., "anthropic:claude-opus:abc123")
|
|
* - Opaque: "ak_xxxx..." (registered AgentApiKey, looked up in database)
|
|
*/
|
|
public function identifyFromMcpToken(string $token): AgentIdentity
|
|
{
|
|
// Check for opaque token format (AgentApiKey)
|
|
// AgentApiKey tokens start with "ak_" prefix
|
|
if (str_starts_with($token, 'ak_')) {
|
|
return $this->identifyFromAgentApiKey($token);
|
|
}
|
|
|
|
// Try structured token format: "provider:model:secret"
|
|
// Expected token formats:
|
|
// - "anthropic:claude-opus:abc123" (provider:model:secret)
|
|
// - "openai:gpt-4:xyz789"
|
|
$parts = explode(':', $token, 3);
|
|
|
|
if (count($parts) >= 2) {
|
|
$provider = strtolower($parts[0]);
|
|
$model = $parts[1] ?? null;
|
|
|
|
// Validate provider is in our known list
|
|
if ($this->isValidProvider($provider)) {
|
|
return $this->createProviderIdentity($provider, $model, AgentIdentity::CONFIDENCE_HIGH);
|
|
}
|
|
}
|
|
|
|
// Unrecognised token format — return unknown with medium confidence
|
|
// (token present suggests agent, but we cannot identify provider)
|
|
return new AgentIdentity('unknown', null, AgentIdentity::CONFIDENCE_MEDIUM);
|
|
}
|
|
|
|
/**
|
|
* Identify an agent from a registered AgentApiKey token.
|
|
*
|
|
* Looks up the token in the database and extracts provider/model
|
|
* from the key's metadata if available.
|
|
*/
|
|
protected function identifyFromAgentApiKey(string $token): AgentIdentity
|
|
{
|
|
$apiKey = AgentApiKey::findByKey($token);
|
|
|
|
if ($apiKey === null) {
|
|
// Token not found in database — invalid or revoked
|
|
return AgentIdentity::unknownAgent();
|
|
}
|
|
|
|
// Check if the key is active
|
|
if (! $apiKey->isActive()) {
|
|
// Expired or revoked key — still an agent, but unknown
|
|
return AgentIdentity::unknownAgent();
|
|
}
|
|
|
|
// Extract provider and model from key name or permissions
|
|
// Key names often follow pattern: "Claude Opus Agent" or "GPT-4 Integration"
|
|
$provider = $this->extractProviderFromKeyName($apiKey->name);
|
|
$model = $this->extractModelFromKeyName($apiKey->name);
|
|
|
|
if ($provider !== null) {
|
|
return $this->createProviderIdentity($provider, $model, AgentIdentity::CONFIDENCE_HIGH);
|
|
}
|
|
|
|
// Valid key but cannot determine provider — return unknown with high confidence
|
|
// (we know it's a registered agent, just not which provider)
|
|
return new AgentIdentity('unknown', null, AgentIdentity::CONFIDENCE_HIGH);
|
|
}
|
|
|
|
/**
|
|
* Extract provider from an API key name.
|
|
*
|
|
* Attempts to identify provider from common naming patterns:
|
|
* - "Claude Agent", "Anthropic Integration" => anthropic
|
|
* - "GPT-4 Agent", "OpenAI Integration" => openai
|
|
* - "Gemini Agent", "Google AI" => google
|
|
*/
|
|
protected function extractProviderFromKeyName(string $name): ?string
|
|
{
|
|
$nameLower = strtolower($name);
|
|
|
|
// Check for provider keywords
|
|
$providerPatterns = [
|
|
'anthropic' => ['anthropic', 'claude'],
|
|
'openai' => ['openai', 'gpt', 'chatgpt', 'o1-'],
|
|
'google' => ['google', 'gemini', 'bard', 'palm'],
|
|
'meta' => ['meta', 'llama'],
|
|
'mistral' => ['mistral', 'mixtral'],
|
|
];
|
|
|
|
foreach ($providerPatterns as $provider => $keywords) {
|
|
foreach ($keywords as $keyword) {
|
|
if (str_contains($nameLower, $keyword)) {
|
|
return $provider;
|
|
}
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* Extract model from an API key name.
|
|
*
|
|
* Attempts to identify specific model from naming patterns:
|
|
* - "Claude Opus Agent" => claude-opus
|
|
* - "GPT-4 Integration" => gpt-4
|
|
*/
|
|
protected function extractModelFromKeyName(string $name): ?string
|
|
{
|
|
$nameLower = strtolower($name);
|
|
|
|
// Check for model keywords
|
|
$modelPatterns = [
|
|
'claude-opus' => ['opus'],
|
|
'claude-sonnet' => ['sonnet'],
|
|
'claude-haiku' => ['haiku'],
|
|
'gpt-4' => ['gpt-4', 'gpt4'],
|
|
'gpt-3.5' => ['gpt-3.5', 'gpt3.5', 'turbo'],
|
|
'o1' => ['o1-preview', 'o1-mini', 'o1 '],
|
|
'gemini-pro' => ['gemini pro', 'gemini-pro'],
|
|
'gemini-flash' => ['gemini flash', 'gemini-flash'],
|
|
'llama-3' => ['llama 3', 'llama-3', 'llama3'],
|
|
];
|
|
|
|
foreach ($modelPatterns as $model => $keywords) {
|
|
foreach ($keywords as $keyword) {
|
|
if (str_contains($nameLower, $keyword)) {
|
|
return $model;
|
|
}
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* Check if the User-Agent looks like a normal web browser.
|
|
*/
|
|
protected function looksLikeBrowser(?string $userAgent): bool
|
|
{
|
|
if (! $userAgent) {
|
|
return false;
|
|
}
|
|
|
|
foreach (self::BROWSER_INDICATORS as $pattern) {
|
|
if (preg_match($pattern, $userAgent)) {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Detect the model from User-Agent patterns.
|
|
*
|
|
* @param array<string, string> $modelPatterns
|
|
*/
|
|
protected function detectModel(string $userAgent, array $modelPatterns): ?string
|
|
{
|
|
foreach ($modelPatterns as $model => $pattern) {
|
|
if (preg_match($pattern, $userAgent)) {
|
|
return $model;
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* Create an identity for a known provider.
|
|
*/
|
|
protected function createProviderIdentity(string $provider, ?string $model, string $confidence): AgentIdentity
|
|
{
|
|
return match ($provider) {
|
|
'anthropic' => AgentIdentity::anthropic($model, $confidence),
|
|
'openai' => AgentIdentity::openai($model, $confidence),
|
|
'google' => AgentIdentity::google($model, $confidence),
|
|
'meta' => AgentIdentity::meta($model, $confidence),
|
|
'mistral' => AgentIdentity::mistral($model, $confidence),
|
|
'local' => AgentIdentity::local($model, $confidence),
|
|
default => new AgentIdentity($provider, $model, $confidence),
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Check if a provider name is valid.
|
|
*/
|
|
public function isValidProvider(string $provider): bool
|
|
{
|
|
return in_array($provider, [
|
|
'anthropic',
|
|
'openai',
|
|
'google',
|
|
'meta',
|
|
'mistral',
|
|
'local',
|
|
'unknown',
|
|
], true);
|
|
}
|
|
|
|
/**
|
|
* Get the list of valid providers.
|
|
*
|
|
* @return string[]
|
|
*/
|
|
public function getValidProviders(): array
|
|
{
|
|
return [
|
|
'anthropic',
|
|
'openai',
|
|
'google',
|
|
'meta',
|
|
'mistral',
|
|
'local',
|
|
'unknown',
|
|
];
|
|
}
|
|
|
|
/**
|
|
* Check if a request appears to be from an AI agent.
|
|
*/
|
|
public function isAgent(Request $request): bool
|
|
{
|
|
return $this->identify($request)->isAgent();
|
|
}
|
|
|
|
/**
|
|
* Check if a User-Agent appears to be from an AI agent.
|
|
*/
|
|
public function isAgentUserAgent(?string $userAgent): bool
|
|
{
|
|
return $this->identifyFromUserAgent($userAgent)->isAgent();
|
|
}
|
|
}
|