CortexServiceProvider.php

<?php

declare(strict_types=1);

namespace Cortex;

use Throwable;
use Cortex\LLM\LLMManager;
use Cortex\Agents\Registry;
use Cortex\Console\AgentChat;
use Cortex\LLM\Contracts\LLM;
use Cortex\Mcp\McpServerManager;
use Illuminate\Support\Facades\Blade;
use Cortex\ModelInfo\ModelInfoFactory;
use Spatie\LaravelPackageTools\Package;
use Cortex\Embeddings\EmbeddingsManager;
use Cortex\Prompts\PromptFactoryManager;
use OpenTelemetry\Contrib\Otlp\Protocols;
use Cortex\Embeddings\Contracts\Embeddings;
use Cortex\Prompts\Contracts\PromptFactory;
use OpenTelemetry\Contrib\Otlp\SpanExporter;
use OpenTelemetry\SDK\Resource\ResourceInfo;
use Illuminate\Contracts\Container\Container;
use Cortex\Support\Events\InternalEventDispatcher;
use OpenTelemetry\SDK\Common\Attribute\Attributes;
use OpenTelemetry\SDK\Common\Util\ShutdownHandler;
use OpenTelemetry\SDK\Trace\TracerProviderBuilder;
use OpenTelemetry\SDK\Resource\ResourceInfoFactory;
use Spatie\LaravelPackageTools\PackageServiceProvider;
use OpenTelemetry\Contrib\Otlp\OtlpHttpTransportFactory;
use OpenTelemetry\SDK\Trace\SpanProcessor\SimpleSpanProcessor;
use Cortex\Support\Events\Subscribers\Otel\OpenTelemetrySubscriber;

class CortexServiceProvider extends PackageServiceProvider
{
    public function configurePackage(Package $package): void
    {
        $package->name('cortex')
            ->hasConfigFile()
            ->hasRoutes('api', 'web')
            ->hasViews('cortex')
            ->hasCommand(AgentChat::class);
    }

    public function packageRegistered(): void
    {
        $this->registerLLMManager();
        $this->registerEmbeddingsManager();
        $this->registerMcpServerManager();
        $this->registerPromptFactoryManager();
        $this->registerModelInfoFactory();
        $this->registerAgentRegistry();
    }

    public function packageBooted(): void
    {
        foreach (config('cortex.agents', []) as $key => $agent) {
            Cortex::registerAgent($agent, is_string($key) ? $key : null);
        }

        $this->registerBladeDirectives();

        $this->setupLogging();
        $this->setupTracing();
    }

    protected function registerBladeDirectives(): void
    {
        // System message directives
        Blade::directive('system', function (): string {
            return '<?php echo "<cortex-message role=\"system\">"; ?>';
        });

        Blade::directive('endsystem', function (): string {
            return '<?php echo "</cortex-message>"; ?>';
        });

        // User message directives
        Blade::directive('user', function (): string {
            return '<?php echo "<cortex-message role=\"user\">"; ?>';
        });

        Blade::directive('enduser', function (): string {
            return '<?php echo "</cortex-message>"; ?>';
        });

        // Assistant message directives
        Blade::directive('assistant', function (): string {
            return '<?php echo "<cortex-message role=\"assistant\">"; ?>';
        });

        Blade::directive('endassistant', function (): string {
            return '<?php echo "</cortex-message>"; ?>';
        });

        // Tool message directives
        Blade::directive('tool', function (string $expression): string {
            return sprintf('<?php echo "<cortex-message role=\"tool\" tool_call_id=\"%s\">"; ?>', $expression);
        });

        Blade::directive('endtool', function (): string {
            return '<?php echo "</cortex-message>"; ?>';
        });
    }

    protected function registerLLMManager(): void
    {
        $this->app->singleton('cortex.llm', fn(Container $app): LLMManager => new LLMManager($app));
        $this->app->alias('cortex.llm', LLMManager::class);
        $this->app->bind(LLM::class, fn(Container $app) => $app->make('cortex.llm')->driver());
    }

    protected function registerEmbeddingsManager(): void
    {
        $this->app->singleton('cortex.embeddings', fn(Container $app): EmbeddingsManager => new EmbeddingsManager($app));
        $this->app->alias('cortex.embeddings', EmbeddingsManager::class);
        $this->app->bind(Embeddings::class, fn(Container $app) => $app->make('cortex.embeddings')->driver());
    }

    protected function registerMcpServerManager(): void
    {
        $this->app->singleton('cortex.mcp_server', fn(Container $app): McpServerManager => new McpServerManager($app));
        $this->app->alias('cortex.mcp_server', McpServerManager::class);
    }

    protected function registerPromptFactoryManager(): void
    {
        $this->app->singleton('cortex.prompt_factory', fn(Container $app): PromptFactoryManager => new PromptFactoryManager($app));
        $this->app->alias('cortex.prompt_factory', PromptFactoryManager::class);
        $this->app->bind(PromptFactory::class, fn(Container $app) => $app->make('cortex.prompt_factory')->driver());
    }

    protected function registerModelInfoFactory(): void
    {
        $this->app->singleton('cortex.model_info_factory', function (Container $app): ModelInfoFactory {
            $providers = [];
            foreach ($app->make('config')->get('cortex.model_info.providers', []) as $provider => $config) {
                // $app->when($provider)
                //     ->needs(CacheInterface::class)
                //     ->give($app->make('cache')->store());

                try {
                    $providers[] = $app->make($provider, is_array($config) ? $config : []);
                } catch (Throwable) {
                    // Silently skip providers that fail to instantiate (e.g., during testbench setup when services aren't available)
                    // This prevents errors during composer autoload/testbench commands
                    continue;
                }
            }

            return new ModelInfoFactory(
                $providers,
                $app->make('cache')->store(),
            );
        });

        $this->app->alias('cortex.model_info_factory', ModelInfoFactory::class);
    }

    protected function registerAgentRegistry(): void
    {
        $this->app->singleton('cortex.agent_registry', fn(Container $app): Registry => new Registry());
        $this->app->alias('cortex.agent_registry', Registry::class);
    }

    protected function setupLogging(): void
    {
        if ($this->app->runningUnitTests()) {
            return;
        }

        // TODO: This will be configurable.
        // $logger = new Logger('cortex');
        // $handler = new StreamHandler('php://stdout');
        // $handler->setFormatter(new LineFormatter());

        // $logger->pushHandler($handler);

        // InternalEventDispatcher::instance()->subscribe(new LoggingSubscriber($logger));
    }

    protected function setupTracing(): void
    {
        if ($this->app->runningUnitTests()) {
            return;
        }

        if (! config('cortex.tracing.enabled', false)) {
            return;
        }

        $endpoint = (string) config('cortex.tracing.exporter.endpoint', 'http://localhost:4318/v1/traces');
        $protocol = (string) config('cortex.tracing.exporter.protocol', Protocols::HTTP_PROTOBUF);
        $serviceName = (string) config('cortex.tracing.service_name', 'cortex');
        $rawHeaders = config('cortex.tracing.exporter.headers', '');
        $headers = [];

        foreach (explode(',', $rawHeaders) as $header) {
            $header = trim($header);

            if ($header === '') {
                continue;
            }

            $parts = explode('=', $header, 2);

            if (count($parts) === 2) {
                [$key, $value] = $parts;
                $headers[trim($key)] = trim($value, " \t\n\r\0\x0B\"'");
            }
        }

        $resource = ResourceInfoFactory::emptyResource()->merge(
            ResourceInfo::create(Attributes::create([
                'service.name' => $serviceName,
            ])),
        );

        $transport = new OtlpHttpTransportFactory()->create(
            $endpoint,
            Protocols::contentType($protocol),
            $headers,
        );

        $exporter = new SpanExporter($transport);

        $tracerProvider = new TracerProviderBuilder()
            ->addSpanProcessor(new SimpleSpanProcessor($exporter))
            ->setResource($resource)
            ->build();

        ShutdownHandler::register($tracerProvider->shutdown(...));

        InternalEventDispatcher::instance()->subscribe(new OpenTelemetrySubscriber($tracerProvider));
    }
}