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

# Demandes de permission

> Contrôlez les demandes de permission de Laravel Copilot SDK via les valeurs par défaut, les gestionnaires intégrés et des callbacks d'approbation personnalisés.

## Demandes de permission

## Comportement par défaut (`deny-all`)

Lorsque `permission_approve` dans `config/copilot.php` vaut `"deny-all"` (par défaut), les demandes de permission émises depuis `Copilot::run()` ou `Copilot::start()` sont automatiquement **refusées**.

Comme les usages orientés génération de texte ne nécessitent souvent pas de permission, c'est une valeur par défaut sûre.

```php theme={null}
// config/copilot.php
'permission_approve' => env('COPILOT_PERMISSION_APPROVE', 'deny-all'),
```

## Valeurs configurables

| Valeur             | Comportement                                                                          |
| ------------------ | ------------------------------------------------------------------------------------- |
| `"deny-all"`       | Tout est refusé automatiquement (**défaut**)                                          |
| `"approve-safety"` | Seuls `shell` et `write` sont refusés, tout le reste est approuvé automatiquement     |
| `"approve-all"`    | Tout est approuvé automatiquement                                                     |
| `false`            | Aucun gestionnaire. `onPermissionRequest` est obligatoire (identique au SDK officiel) |

```php theme={null}
// .env
COPILOT_PERMISSION_APPROVE="approve-safety"
```

<Warning>
  Lorsque vous acceptez des prompts saisis par l'utilisateur, `"approve-safety"` et `"approve-all"` sont dangereux.
  Utilisez impérativement `false` ou `"deny-all"`.
  Même avec des permissions en lecture seule, le code du projet Laravel peut être lu.
</Warning>

## `PermissionHandler::approveAll()`

`PermissionHandler::approveAll()` approuve automatiquement toutes les demandes.

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

$config = new SessionConfig(
    onPermissionRequest: PermissionHandler::approveAll(),
);

$response = Copilot::run(prompt: 'Hello', config: $config);
```

## `PermissionHandler::approveSafety()`

`PermissionHandler::approveSafety()` refuse uniquement les permissions à haut risque (`shell`, `write`) et approuve automatiquement le reste.

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

$config = new SessionConfig(
    onPermissionRequest: PermissionHandler::approveSafety(),
);

$response = Copilot::run(prompt: 'Hello', config: $config);
```

Ce n'est pas totalement sûr pour autant.
Pour un contrôle strict, implémentez un gestionnaire personnalisé qui se base sur `$request['kind']`.

## `PermissionHandler::denyAll()`

`PermissionHandler::denyAll()` refuse tout.

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

$config = new SessionConfig(
    onPermissionRequest: PermissionHandler::denyAll(),
);
```

## Utilisation directe du Client

Si vous utilisez `CopilotClient` directement, `onPermissionRequest` est **obligatoire**, comme dans le SDK officiel.

```php theme={null}
use Revolution\Copilot\Client;
use Revolution\Copilot\Support\PermissionHandler;

$client = new Client([
    'cli_path' => 'copilot',
    'cli_args' => [],
    'cwd' => base_path(),
    'log_level' => 'info',
    'env' => null,
]);
$client->start();

// onPermissionRequest est obligatoire
$session = $client->createSession([
    'onPermissionRequest' => PermissionHandler::approveSafety(),
]);

// Si omis, InvalidArgumentException est levée
// $session = $client->createSession([]); // Error!
```

## Gestionnaire personnalisé

Pour contrôler l'approbation par type de requête, passez une closure.
`$request` et `$invocation` sont des tableaux comme suit.

```php theme={null}
use Illuminate\Support\Facades\Artisan;
use Revolution\Copilot\Contracts\CopilotSession;
use Revolution\Copilot\Facades\Copilot;
use Revolution\Copilot\Support\PermissionRequestResultKind;
use Revolution\Copilot\Types\SessionConfig;

use function Laravel\Prompts\{confirm, note, spin, text};

Artisan::command('copilot:chat', function () {
    $config = new SessionConfig(
        onPermissionRequest: function (array $request, array $invocation) {
            $confirm = confirm(
                label: 'Do you accept the requested permissions?',
            );
            if ($confirm) {
                return PermissionRequestResultKind::approveOnce();
            } else {
                return PermissionRequestResultKind::reject();
            }
        },
    );

    Copilot::start(function (CopilotSession $session) use ($config) {
        while (true) {
            $prompt = text(
                label: 'Enter your prompt',
                placeholder: 'Ask me anything...',
                required: true,
                hint: 'Ctrl+C to exit',
            );

            $response = spin(
                callback: fn () => $session->sendAndWait($prompt),
                message: 'Waiting for Copilot response...',
            );

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

### `$request`

Les champs autres que `kind` et `toolCallId` varient selon `kind`.

```text theme={null}
kind: "shell" | "write" | "mcp" | "read" | "url" | "custom-tool" | "memory" | "hook"
```

```php theme={null}
[
  "kind" => "shell",
  "toolCallId" => "toolu_...",
  "fullCommandText" => "...",
  "intention" => "Run copilot:ping to test permission request",
  "commands" => [
    [
      "identifier" => "bash",
      "readOnly" => false,
    ]
  ]
  "possiblePaths" => [],
  "possibleUrls" => [],
  "hasWriteFileRedirection" => false,
  "canOfferSessionApproval" => false,
]
```

### `$invocation`

```php theme={null}
[
  "sessionId" => "...",
]
```

## Réponse

Le résultat de la décision est renvoyé sous forme de tableau.
La classe `PermissionRequestResultKind` la rend plus lisible.

```php theme={null}
return PermissionRequestResultKind::approveOnce();
return PermissionRequestResultKind::reject();
```

## Détails du protocole

Dans le Protocol v3 (défaut actuel), la demande de permission n'est pas une requête JSON-RPC mais un événement de session (`permission.requested`).
Le SDK le traite en interne et répond via le RPC `session.permissions.handlePendingPermissionRequest`.

**L'usage de `SessionConfig` ne change pas.**
Si vous fournissez un gestionnaire à `onPermissionRequest`, le SDK absorbe les différences de protocole.

## PermissionRequestResultKind

Vous pouvez renvoyer directement `['kind' => 'approve-once']`, mais `PermissionRequestResultKind` rend le code plus clair.

```php theme={null}
use Revolution\Copilot\Support\PermissionRequestResultKind;

$confirm = confirm(
    label: 'Do you accept the requested permissions?',
);

if ($confirm) {
    return PermissionRequestResultKind::approveOnce();
} else {
    return PermissionRequestResultKind::reject();
}
```

### Méthodes disponibles

| Méthode                | Valeur                 | Description                                                                     |
| ---------------------- | ---------------------- | ------------------------------------------------------------------------------- |
| `approveOnce()`        | `approve-once`         | Autorise uniquement la requête courante                                         |
| `approveForSession()`  | `approve-for-session`  | Autorise toutes les requêtes du même type pendant cette session                 |
| `approveForLocation()` | `approve-for-location` | Autorise toutes les requêtes du même type depuis cet emplacement (chemin, etc.) |
| `reject()`             | `reject`               | Refuse la requête                                                               |
| `userNotAvailable()`   | `user-not-available`   | Utilisateur indisponible (environnement non interactif, etc.)                   |
| `noResult()`           | `no-result`            | Le gestionnaire ne peut pas renvoyer de résultat (ignore l'appel RPC)           |

Pour utiliser `Laravel\Prompts\select`, `PermissionRequestResultKind::select()` fournit les options.

```php theme={null}
use Revolution\Copilot\Support\PermissionRequestResultKind;
use function Laravel\Prompts\select;

$select = select(
    label: 'Do you accept the requested permissions?',
    options: PermissionRequestResultKind::select(),
);

return ['kind' => $select];
```

### no-result

Si le gestionnaire ne peut pas renvoyer de résultat (par ex. en environnement non interactif), utilisez `no-result`.
Renvoyer `no-result` ignore l'appel RPC et applique le refus par défaut côté Copilot CLI.

```php theme={null}
return PermissionRequestResultKind::noResult();
// ou ['kind' => 'no-result']
```

<Info>
  Pour les dernières informations, consultez le [dépôt GitHub](https://github.com/invokable/laravel-copilot-sdk).
</Info>


## Related topics

- [Liste des sites pris en charge - Feedable](/fr/packages/feedable/drivers.md)
- [Réinitialisation du mot de passe](/fr/passwords.md)
- [Événements de streaming](/fr/packages/laravel-copilot-sdk/streaming-events.md)
- [Hooks de session](/fr/packages/laravel-copilot-sdk/hooks.md)
- [Démarrer - GitHub Copilot SDK pour Laravel](/fr/packages/laravel-copilot-sdk/getting-started.md)