<?php
require_once 'vendor/autoload.php';

use BlockshiftNetwork\Composio\Configuration;

// Configure API key
$config = Configuration::getDefaultConfiguration()
    ->setApiKey('x-api-key', 'YOUR_API_KEY')
    ->setHost('https://backend.composio.dev');

$config = Configuration::getDefaultConfiguration()
    ->setApiKey('authToken', 'YOUR_SESSION_TOKEN')
    ->setApiKeyPrefix('authToken', '');

$config = Configuration::getDefaultConfiguration()
    ->setApiKey('x-org-api-key', 'YOUR_ORG_API_KEY');

<?php
require_once 'vendor/autoload.php';

use BlockshiftNetwork\Composio\Configuration;
use BlockshiftNetwork\Composio\Api\ToolkitsApi;
use GuzzleHttp\Client;

// Configure authentication
$config = Configuration::getDefaultConfiguration()
    ->setApiKey('x-api-key', 'YOUR_API_KEY');

// Create API instance
$api = new ToolkitsApi(
    new Client(),
    $config
);

try {
    // List all available toolkits
    $result = $api->getToolkits();

    echo "Available toolkits:\n";
    foreach ($result->getItems() as $toolkit) {
        echo "- {$toolkit->getName()} ({$toolkit->getSlug()})\n";
        echo "  Description: {$toolkit->getMeta()->getDescription()}\n";
        echo "  Categories: " . implode(', ', $toolkit->getMeta()->getCategories()) . "\n\n";
    }
} catch (Exception $e) {
    echo "Error: " . $e->getMessage() . "\n";
}

<?php
use BlockshiftNetwork\Composio\Api\ToolsApi;
use BlockshiftNetwork\Composio\Model\PostToolsExecuteByToolSlugRequest;

// Create tools API instance
$toolsApi = new ToolsApi(
    new Client(),
    $config
);

// Execute a specific tool
$request = new PostToolsExecuteByToolSlugRequest([
    'arguments' => [
        'repository' => 'username/repository',
        'title' => 'Issue created from PHP SDK',
        'body' => 'This issue was created automatically using Composio PHP SDK'
    ],
    'connected_account_id' => 'CONNECTED_ACCOUNT_ID'
]);

try {
    $result = $toolsApi->postToolsExecuteByToolSlug('github_create_issue', $request);
    echo "Issue created successfully:\n";
    echo "URL: {$result->getData()->html_url}\n";
} catch (Exception $e) {
    echo "Error executing tool: " . $e->getMessage() . "\n";
}

<?php
use BlockshiftNetwork\Composio\Api\ConnectedAccountsApi;

$connectedAccountsApi = new ConnectedAccountsApi(
    new Client(),
    $config
);

try {
    // List connected accounts
    $accounts = $connectedAccountsApi->getConnectedAccounts();

    echo "Connected accounts:\n";
    foreach ($accounts->getItems() as $account) {
        echo "- {$account->getToolkit()->getName()}: ";
        echo $account->getStatus() === 'ACTIVE' ? '✅ Active' : '❌ Inactive';
        echo "\n";
    }
} catch (Exception $e) {
    echo "Error: " . $e->getMessage() . "\n";
}

<?php
use BlockshiftNetwork\Composio\Api\ToolRouterApi;
use BlockshiftNetwork\Composio\Model\PostToolRouterSessionRequest;

$toolRouterApi = new ToolRouterApi(new Client(), $config);

// Create a Tool Router session
$sessionRequest = new PostToolRouterSessionRequest([
    'user_id' => 'user_123',
    'config' => [
        'toolkits' => [
            'enabled' => ['github', 'slack', 'gmail']
        ]
    ]
]);

$session = $toolRouterApi->postToolRouterSession($sessionRequest);
echo "Session created: {$session->getSessionId()}\n";

// Execute in session
$executeRequest = [
    'tool_slug' => 'github_create_issue',
    'arguments' => [
        'repository' => 'user/repo',
        'title' => 'Issue from Tool Router'
    ]
];

$result = $toolRouterApi->postToolRouterSessionBySessionIdExecute(
    $session->getSessionId(),
    $executeRequest
);

<?php
use BlockshiftNetwork\Composio\ApiException;

try {
    $result = $api->someMethod();
} catch (ApiException $e) {
    echo "API Error: {$e->getCode()} {$e->getMessage()}\n";
    echo "Response body: {$e->getResponseBody()}\n";
    echo "Response headers: " . json_encode($e->getResponseHeaders()) . "\n";
} catch (Exception $e) {
    echo "General error: " . $e->getMessage() . "\n";
}

// App/Http/Controllers/ComposioController.php
namespace App\Http\Controllers;

use BlockshiftNetwork\Composio\Configuration;
use BlockshiftNetwork\Composio\Api\ToolkitsApi;

class ComposioController extends Controller
{
    protected $config;
    protected $api;

    public function __construct()
    {
        $this->config = Configuration::getDefaultConfiguration()
            ->setApiKey('x-api-key', config('services.composio.api_key'));

        $this->api = new ToolkitsApi(
            new \GuzzleHttp\Client(),
            $this->config
        );
    }

    public function index()
    {
        $toolkits = $this->api->getToolkits();
        return view('composio.index', ['toolkits' => $toolkits->getItems()]);
    }
}

// src/Service/ComposioService.php
namespace App\Service;

use BlockshiftNetwork\Composio\Configuration;
use BlockshiftNetwork\Composio\Api\ToolsApi;

class ComposioService
{
    private Configuration $config;
    private ToolsApi $toolsApi;

    public function __construct(string $apiKey)
    {
        $this->config = Configuration::getDefaultConfiguration()
            ->setApiKey('x-api-key', $apiKey);

        $this->toolsApi = new ToolsApi(
            new \GuzzleHttp\Client(),
            $this->config
        );
    }

    public function executeTool(string $toolSlug, array $arguments): array
    {
        $request = new \BlockshiftNetwork\Composio\Model\PostToolsExecuteByToolSlugRequest([
            'arguments' => $arguments
        ]);

        $result = $this->toolsApi->postToolsExecuteByToolSlug($toolSlug, $request);

        return $result->getData();
    }
}

// Environment variables
$config = Configuration::getDefaultConfiguration()
    ->setApiKey('x-api-key', $_ENV['COMPOSIO_API_KEY'])
    ->setHost($_ENV['COMPOSIO_API_HOST'] ?? 'https://backend.composio.dev');

class ComposioClientFactory
{
    private static ?Configuration $config = null;

    public static function getConfig(): Configuration
    {
        if (self::$config === null) {
            self::$config = Configuration::getDefaultConfiguration()
                ->setApiKey('x-api-key', $_ENV['COMPOSIO_API_KEY']);
        }

        return self::$config;
    }

    public static function createToolkitsApi(): ToolkitsApi
    {
        return new ToolkitsApi(
            new \GuzzleHttp\Client([
                'timeout' => 30,
                'connect_timeout' => 10
            ]),
            self::getConfig()
        );
    }
}

use Monolog\Logger;
use Monolog\Handler\StreamHandler;

$logger = new Logger('composio');
$logger->pushHandler(new StreamHandler('logs/composio.log', Logger::DEBUG));

// Add middleware to Guzzle for logging
$client = new \GuzzleHttp\Client([
    'handler' => \GuzzleHttp\HandlerStack::create(),
]);

$handler = $client->getConfig('handler');
$handler->push(\GuzzleHttp\Middleware::log(
    $logger,
    new \GuzzleHttp\MessageFormatter('{method} {uri} - {code} - {req_body}')
));