> ## Documentation Index
> Fetch the complete documentation index at: https://kawax.biz/llms.txt
> Use this file to discover all available pages before exploring further.

# Démarrer - GitHub Copilot SDK pour Laravel

> Créez votre première commande Laravel utilisant Copilot et apprenez les workflows de base de Laravel Copilot SDK.

## Créer une première application Laravel compatible Copilot

Ce guide vous fait construire un assistant en ligne de commande avec Laravel Copilot SDK.
Vous commencez par l'envoi d'un prompt unique, puis vous progressez vers les sessions, les événements et les outils.

## Prérequis

Avant de commencer, vérifiez ce qui suit :

* Le GitHub Copilot CLI est installé et authentifié
* PHP `8.4+`
* Laravel `13.x`

Vérifiez que le CLI est disponible :

```bash theme={null}
copilot --version
```

## Installer le SDK

Installez le paquet via Composer :

```bash theme={null}
composer require revolution/laravel-copilot-sdk
```

Publiez la configuration si nécessaire :

```bash theme={null}
php artisan vendor:publish --tag=copilot-config
```

Si besoin, configurez le chemin du CLI dans `.env` :

```dotenv theme={null}
COPILOT_CLI_PATH=copilot
```

## Envoyer un premier message

Créez une commande et appelez `Copilot::run()` :

```php theme={null}
<?php

namespace App\Console\Commands;

use Illuminate\Console\Command;
use Revolution\Copilot\Facades\Copilot;

class CopilotDemo extends Command
{
    protected $signature = 'copilot:demo';
    protected $description = 'Demo Copilot SDK';

    public function handle()
    {
        $response = Copilot::run(prompt: 'What is 2 + 2?');

        $this->info($response->content());
    }
}
```

Exécutez la commande :

```bash theme={null}
php artisan copilot:demo
```

## Maintenir le contexte grâce à une session

Pour utiliser plusieurs prompts dans une même conversation, utilisez `Copilot::start()` :

```php theme={null}
use Revolution\Copilot\Contracts\CopilotSession;
use Revolution\Copilot\Facades\Copilot;

Copilot::start(function (CopilotSession $session) {
    $response = $session->sendAndWait(prompt: 'What is 2 + 2?');
    $this->info('Answer: '.$response->content());

    $response = $session->sendAndWait(prompt: 'Now multiply that by 3');
    $this->info('Answer: '.$response->content());
});
```

## Traiter les événements de session

Enregistrez un gestionnaire d'événements via `on()` pour observer les messages de l'assistant et les échecs.

```php theme={null}
use Revolution\Copilot\Contracts\CopilotSession;
use Revolution\Copilot\Facades\Copilot;
use Revolution\Copilot\Types\SessionEvent;

Copilot::start(function (CopilotSession $session) {
    $session->on(function (SessionEvent $event): void {
        if ($event->isAssistantMessage()) {
            $this->info($event->content());
        } elseif ($event->failed()) {
            $this->error($event->errorMessage() ?? 'Unknown error');
        }
    });

    $session->sendAndWait(prompt: 'Tell me a short Laravel joke');
});
```

## Ajouter un outil personnalisé

Définissez un outil avec un schéma JSON et un gestionnaire :

```php theme={null}
use Illuminate\JsonSchema\JsonSchema;
use Revolution\Copilot\Contracts\CopilotSession;
use Revolution\Copilot\Facades\Copilot;
use Revolution\Copilot\Types\SessionConfig;
use Revolution\Copilot\Types\Tool;

$parameters = JsonSchema::object([
    'topic' => JsonSchema::string()
        ->description('Topic to look up')
        ->required(),
])->toArray();

$config = new SessionConfig(
    tools: [
        Tool::define(
            name: 'lookup_fact',
            description: 'Returns a fact for a topic.',
            parameters: $parameters,
            handler: function (array $params): array {
                $topic = $params['topic'] ?? '';

                return [
                    'textResultForLlm' => "Fact for {$topic}",
                    'resultType' => 'success',
                    'sessionLog' => "lookup_fact: {$topic}",
                    'toolTelemetry' => [],
                ];
            },
        ),
    ],
);

Copilot::start(function (CopilotSession $session) {
    $response = $session->sendAndWait(
        prompt: 'Use lookup_fact to tell me something about Laravel.'
    );

    $this->info($response->content());
}, config: $config);
```

## Construire un assistant interactif

En combinant sessions, événements et outils, vous pouvez construire une commande Artisan interactive.

```php theme={null}
<?php

namespace App\Console\Commands;

use Illuminate\Console\Command;
use Illuminate\JsonSchema\JsonSchema;
use Revolution\Copilot\Contracts\CopilotSession;
use Revolution\Copilot\Facades\Copilot;
use Revolution\Copilot\Types\SessionConfig;
use Revolution\Copilot\Types\SessionEvent;
use Revolution\Copilot\Types\Tool;
use Revolution\Copilot\Types\ToolResultObject;

use function Laravel\Prompts\error;
use function Laravel\Prompts\info;
use function Laravel\Prompts\note;
use function Laravel\Prompts\spin;
use function Laravel\Prompts\text;

class CopilotAssistant extends Command
{
    protected $signature = 'copilot:assistant';
    protected $description = 'Interactive Copilot assistant';

    public function handle()
    {
        $facts = [
            'PHP' => 'A popular general-purpose scripting language for web development.',
            'Laravel' => 'A web application framework with expressive, elegant syntax.',
            'Composer' => 'Dependency manager for PHP.',
        ];

        $parameters = JsonSchema::object([
            'topic' => JsonSchema::string()
                ->description('Topic to look up')
                ->required(),
        ])->toArray();

        $config = new SessionConfig(
            tools: [
                Tool::define(
                    name: 'lookup_fact',
                    description: 'Returns a fun fact about a given topic.',
                    parameters: $parameters,
                    handler: function (array $params) use ($facts) {
                        $topic = $params['topic'] ?? '';
                        $fact = $facts[$topic] ?? "No fact available for {$topic}.";

                        return new ToolResultObject(
                            textResultForLlm: $fact,
                            resultType: 'success',
                            sessionLog: "lookup_fact: {$topic}",
                            toolTelemetry: [],
                        );
                    },
                ),
            ],
        );

        Copilot::start(function (CopilotSession $session) {
            info('Copilot assistant');
            info("Session: {$session->id()}");
            info("Try: Use lookup_fact to tell me about Laravel");

            $session->on(function (SessionEvent $event): void {
                if ($event->isAssistantMessage()) {
                    note($event->content());
                } elseif ($event->failed()) {
                    error($event->errorMessage() ?? 'Unknown error');
                }
            });

            while (true) {
                $prompt = text(
                    label: 'You',
                    placeholder: 'Ask me anything...',
                    required: true,
                    hint: 'Ctrl+C to exit',
                );

                spin(
                    callback: fn () => $session->sendAndWait($prompt),
                    message: 'Thinking...',
                );

                echo "\n";
            }
        }, config: $config);
    }
}
```

Exécutez la commande :

```bash theme={null}
php artisan copilot:assistant
```

## Fonctionnement d'un outil

Lorsque vous définissez un outil, précisez trois choses :

1. Ce que fait l'outil.
2. Les paramètres qu'il reçoit.
3. Le code du gestionnaire à exécuter.

Copilot décide s'il faut appeler l'outil selon l'entrée utilisateur, et le SDK exécute le gestionnaire puis renvoie le résultat.

## Fonctionnalités à explorer ensuite

### Connecter un serveur MCP

```php theme={null}
use Revolution\Copilot\Types\SessionConfig;

$config = new SessionConfig(
    mcpServers: [
        'github' => [
            'type' => 'http',
            'url' => 'https://api.githubcopilot.com/mcp/',
        ],
    ],
);
```

### Créer un agent personnalisé

```php theme={null}
use Revolution\Copilot\Types\SessionConfig;

$config = new SessionConfig(
    customAgents: [
        [
            'name' => 'pr-reviewer',
            'displayName' => 'PR Reviewer',
            'description' => 'Reviews pull requests for best practices',
            'prompt' => 'You are an expert code reviewer. Focus on security, performance, and maintainability.',
        ],
    ],
);
```

### Personnaliser le message système

```php theme={null}
use Revolution\Copilot\Types\SessionConfig;
use Revolution\Copilot\Types\SystemMessageConfig;

$config = new SessionConfig(
    systemMessage: new SystemMessageConfig(
        content: 'You are a helpful assistant for our engineering team. Always be concise.',
    ),
);
```

## Se connecter à un serveur CLI externe

Démarrez le Copilot CLI en mode serveur :

```bash theme={null}
copilot --headless --port 4321
```

Ensuite, configurez l'URL de connexion dans `.env` :

```dotenv theme={null}
COPILOT_URL=tcp://127.0.0.1:4321
```

Lorsque `COPILOT_URL` est défini, le SDK ne lance pas un nouveau processus CLI et se connecte au serveur existant.

## Télémétrie et observabilité

Configurez la télémétrie dans `config/copilot.php` :

```php theme={null}
'telemetry' => [
    'otlpEndpoint' => 'http://localhost:4318',
],
```

Ou directement :

```php theme={null}
use Revolution\Copilot\Facades\Copilot;
use Revolution\Copilot\Types\TelemetryConfig;

Copilot::useStdio([
    'telemetry' => new TelemetryConfig(
        otlpEndpoint: 'http://localhost:4318',
    ),
]);
```

## Aller plus loin

* [Authentification](/fr/packages/laravel-copilot-sdk/auth)
* [MCP](/fr/packages/laravel-copilot-sdk/mcp)
* [Fournisseurs personnalisés](/fr/packages/laravel-copilot-sdk/custom-providers)
* [Télémétrie](/fr/packages/laravel-copilot-sdk/telemetry)
* [SessionConfig](/fr/packages/laravel-copilot-sdk/session-config)
* [SessionEvent](/fr/packages/laravel-copilot-sdk/session-event)
* [Aperçu de Laravel Copilot SDK](/fr/packages/laravel-copilot-sdk)
* [Dépôt du SDK officiel](https://github.com/github/copilot-sdk)

## Étapes suivantes

<Columns cols={2}>
  <Card title="Authentification" href="/fr/packages/laravel-copilot-sdk/auth">
    Choisissez la méthode d'authentification adaptée au local et au CI.
  </Card>

  <Card title="SessionConfig" href="/fr/packages/laravel-copilot-sdk/session-config">
    Configurez le modèle, les hooks, les serveurs MCP et le comportement d'exécution.
  </Card>

  <Card title="SessionEvent" href="/fr/packages/laravel-copilot-sdk/session-event">
    Comprenez les helpers d'événements spécifiques à Laravel et la gestion du cycle de vie.
  </Card>

  <Card title="Demandes de permission" href="/fr/packages/laravel-copilot-sdk/permission-request">
    Passez en revue le flux d'autorisation exigeant une approbation explicite pour exécuter des outils.
  </Card>

  <Card title="Outils" href="/fr/packages/laravel-copilot-sdk/tools">
    Invoquez le code de votre application depuis Copilot.
  </Card>

  <Card title="MCP" href="/fr/packages/laravel-copilot-sdk/mcp">
    Branchez les outils prêts à l'emploi des serveurs MCP.
  </Card>
</Columns>

À ce stade, vous avez parcouru le flux central de Laravel Copilot SDK, depuis un prompt unique jusqu'à une session avec outils.

<Info>
  Références : [Laravel Copilot SDK README](https://github.com/invokable/laravel-copilot-sdk/blob/main/README.md), [Laravel Copilot SDK Getting Started](https://github.com/invokable/laravel-copilot-sdk/blob/main/docs/getting-started.md), [GitHub Copilot SDK](https://github.com/github/copilot-sdk)
</Info>


## Related topics

- [GitHub Copilot SDK pour Laravel](/fr/packages/laravel-copilot-sdk/index.md)
- [GitHub Actions - GitHub Copilot SDK pour Laravel](/fr/packages/laravel-copilot-sdk/github-actions.md)
- [Tests - GitHub Copilot SDK pour Laravel](/fr/packages/laravel-copilot-sdk/fake.md)
- [Authentification - GitHub Copilot SDK pour Laravel](/fr/packages/laravel-copilot-sdk/auth.md)
- [Laravel Cloud - GitHub Copilot SDK pour Laravel](/fr/packages/laravel-copilot-sdk/laravel-cloud.md)