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

# RPC (Remote Procedure Call)

> Roep protocolmethodes voor modellen, tools, permissies en meer aan met de ServerRpc en SessionRpc van de Laravel Copilot SDK.

## RPC (Remote Procedure Call)

In de officiële SDK worden recente nieuwe functies ondersteund via automatische codegeneratie op basis van `api.schema.json`. De Laravel-versie is op dezelfde manier geïmplementeerd, met de gegenereerde versies voor andere talen als referentie.

## ServerRpc

De RPC-klasse die aan de Client is gekoppeld.

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

// De modellenlijst ophalen
// De returnwaarde is een ModelList
$result = Copilot::client()->rpc()->models()->list();
// models is een array van ModelInfo
$models = $result->models;

// Vrijwel gelijk aan het al bestaande listModels()
// De returnwaarde is een array van ModelInfo
Copilot::client()->listModels();
```

Functionaliteit die al in de SDK zat, is in de automatisch gegenereerde versie opnieuw toegevoegd.

### Overzicht van methodes

```php theme={null}
Copilot::client()->rpc()->ping();

// models
Copilot::client()->rpc()->models()->list();
// Ophalen met een GitHub-token per session
Copilot::client()->rpc()->models()->list(new ModelsListRequest(gitHubToken: $token));

// tools
Copilot::client()->rpc()->tools()->list();

// account
Copilot::client()->rpc()->account()->getQuota();
// Ophalen met een GitHub-token per session
Copilot::client()->rpc()->account()->getQuota(new AccountGetQuotaRequest(gitHubToken: $token));

// mcp config (beheer van MCP-serverconfiguratie)
Copilot::client()->rpc()->mcp()->list();
Copilot::client()->rpc()->mcp()->add(new McpConfigAddRequest(
    name: 'my-server',
    config: new McpServerValue(type: 'local', command: 'php', args: ['artisan', 'mcp']),
));
Copilot::client()->rpc()->mcp()->update(new McpConfigUpdateRequest(
    name: 'my-server',
    config: new McpServerValue(type: 'http', url: 'https://mcp.example.com'),
));
Copilot::client()->rpc()->mcp()->remove(new McpConfigRemoveRequest(name: 'my-server'));
// MCP-servers in-/uitschakelen (globale configuratie)
Copilot::client()->rpc()->mcp()->enable(new McpConfigEnableRequest(names: ['my-server']));
Copilot::client()->rpc()->mcp()->disable(new McpConfigDisableRequest(names: ['my-server']));

// mcp discover (automatische detectie van MCP-servers)
Copilot::client()->rpc()->mcp()->discover(new McpDiscoverRequest(
    workingDirectory: '/path/to/project',
));
// Kan ook zonder argumenten worden uitgevoerd
$result = Copilot::client()->rpc()->mcp()->discover();
// $result->servers is an array of DiscoveredMcpServer

// sessionFs (registratie van de session-filesystem-provider)
Copilot::client()->rpc()->sessionFs()->setProvider(new SessionFsSetProviderRequest(
    initialCwd: '/path/to/project',
    sessionStatePath: '.copilot/sessions',
    conventions: 'posix',
));

// sessions (experimenteel: een session forken)
Copilot::client()->rpc()->sessions()->fork(new SessionsForkRequest(
    sessionId: 'source-session-id',
    toEventId: 'evt-boundary', // Optioneel: alleen events vóór deze ID opnemen
));

// skills (skillbeheer op serverniveau)
// Skills ontdekken
$result = Copilot::client()->rpc()->skills()->discover();
// $result->skills is een array van ServerSkill
// Optioneel een projectpad opgeven
$result = Copilot::client()->rpc()->skills()->discover(new SkillsDiscoverRequest(
    projectPaths: ['/path/to/project'],
    skillDirectories: ['/custom/skills'],
));

// Instellen welke skills worden uitgeschakeld
Copilot::client()->rpc()->skills()->config()->setDisabledSkills(
    new SkillsConfigSetDisabledSkillsRequest(disabledSkills: ['skill-name'])
);
```

## SessionRpc

De RPC-klasse die aan een Session is gekoppeld.

Hiermee is bijvoorbeeld het gebruik van de plan-modus mogelijk, wat met de eerdere SDK niet kon.

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

Copilot::start(function (CopilotSession $session) {
    $session->rpc()->mode()->set(new ModeSetRequest(mode: 'plan'));

    $response = $session->sendAndWait(prompt: 'Maak een plan voor X');

    $result = $session->rpc()->plan()->read();
    dump($result->content);

    $session->rpc()->mode()->set(new ModeSetRequest(mode: 'autopilot'));

    $response = $session->sendAndWait(prompt: 'Implementeer volgens het plan');
    dump($response->content());
});
```

### Overzicht van methodes

```php theme={null}
// model
$session->rpc()->model()->getCurrent();
$session->rpc()->model()->switchTo(new ModelSwitchToRequest(modelId: 'gpt-4'));
// Bij het opgeven van reasoningEffort (alleen ondersteunde modellen)
$session->rpc()->model()->switchTo(new ModelSwitchToRequest(modelId: 'claude-opus-4.7', reasoningEffort: ReasoningEffort::HIGH));
// Bij het overschrijven van modelCapabilities
$session->rpc()->model()->switchTo(new ModelSwitchToRequest(
    modelId: 'gpt-4',
    modelCapabilities: new ModelCapabilitiesOverride(
        supports: new ModelCapabilitiesOverrideSupports(vision: true),
    ),
));

// Met de setModel()-helper kun je op dezelfde manier reasoningEffort en modelCapabilities opgeven
$session->setModel('claude-opus-4.7', ReasoningEffort::HIGH);
$session->setModel('claude-opus-4.7', 'high'); // String is also supported
$session->setModel('gpt-4', modelCapabilities: ['supports' => ['vision' => true]]); // Kan ook als array

// mode
$session->rpc()->mode()->get();
$session->rpc()->mode()->set(new ModeSetRequest(mode: 'plan'));

// name
$session->rpc()->name()->get();
$session->rpc()->name()->set(new NameSetRequest(name: 'My Session'));

// plan
$session->rpc()->plan()->read();
$session->rpc()->plan()->update(new PlanUpdateRequest(content: '...'));
$session->rpc()->plan()->delete();

// workspaces
$session->rpc()->workspaces()->getWorkspace();
$session->rpc()->workspaces()->listFiles();
$session->rpc()->workspaces()->readFile(new WorkspacesReadFileRequest(path: 'file.txt'));
$session->rpc()->workspaces()->createFile(new WorkspacesCreateFileRequest(path: 'file.txt', content: '...'));

// instructions (de instructiebronnen van de session ophalen)
$result = $session->rpc()->instructions()->getSources();
// $result->sources - een array van InstructionsSources

// fleet
$session->rpc()->fleet()->start(new FleetStartRequest(prompt: '...'));
// Zie Fleet Mode voor details

// agent
$session->rpc()->agent()->list();
$session->rpc()->agent()->getCurrent();
$session->rpc()->agent()->select(new AgentSelectRequest(agentId: '...'));
$session->rpc()->agent()->deselect();
$session->rpc()->agent()->reload();

// skills (experimenteel: beheer van skills)
$session->rpc()->skills()->list();
$session->rpc()->skills()->enable(new SkillsEnableRequest(name: 'skill-name'));
$session->rpc()->skills()->disable(new SkillsDisableRequest(name: 'skill-name'));
$session->rpc()->skills()->reload();

// mcp (experimenteel: beheer van MCP-servers)
$session->rpc()->mcp()->list();
$session->rpc()->mcp()->enable(new McpEnableRequest(serverName: 'server-name'));
$session->rpc()->mcp()->disable(new McpDisableRequest(serverName: 'server-name'));
$session->rpc()->mcp()->reload();
// MCP OAuth-login (voor MCP-servers die authenticatie vereisen)
$result = $session->rpc()->mcp()->login(new McpOauthLoginRequest(serverName: 'my-server'));
// $result->authorizationUrl - de URL van de OAuth-flow (indien authenticatie nodig is)

// plugins (experimenteel: overzicht van plugins)
$session->rpc()->plugins()->list();

// extensions (experimenteel: beheer van extensies)
$session->rpc()->extensions()->list();
$session->rpc()->extensions()->enable(new ExtensionsEnableRequest(id: 'project:my-ext'));
$session->rpc()->extensions()->disable(new ExtensionsDisableRequest(id: 'project:my-ext'));
$session->rpc()->extensions()->reload();

// compaction → hernoemd naar history
$session->rpc()->history()->compact();
// De geschiedenis vanaf een bepaald event afkappen
$session->rpc()->history()->truncate(new HistoryTruncateRequest(
    eventId: 'evt-123', // Dit event en alle events erna worden verwijderd
));

// tools (protocol v3+: antwoord op het event external_tool.requested)
$session->rpc()->tools()->handlePendingToolCall(new ToolsHandlePendingToolCallRequest(
    requestId: '...',
    result: 'Resultaat van de tool',
));

// permissions (protocol v3+: antwoord op het event permission.requested)
$session->rpc()->permissions()->handlePendingPermissionRequest(new PermissionDecisionRequest(
    requestId: '...',
    result: PermissionRequestResultKind::approveOnce(),
));
// Alle permission requests binnen de session automatisch goedkeuren
$session->rpc()->permissions()->setApproveAll(new PermissionsSetApproveAllRequest(enabled: true));
// Sessionscoped permissiegoedkeuringen resetten
$session->rpc()->permissions()->resetSessionApprovals();

// commands: antwoord op command-aanroep-events
$session->rpc()->commands()->handlePendingCommand(new CommandsHandlePendingCommandRequest(
    requestId: '...',
));

// ui: antwoord op UI-elicitatierequests
$session->rpc()->ui()->elicitation(new UIElicitationRequest(
    message: 'Vraag aan de gebruiker',
    requestedSchema: ['type' => 'object', 'properties' => [...]],
));

// ui: antwoord op een openstaande elicitatierequest (via het event elicitation.requested)
$session->rpc()->ui()->handlePendingElicitation(new UIHandlePendingElicitationRequest(
    requestId: '...',
    result: ['action' => 'accept', 'content' => ['name' => 'John']],
));

// log: berichten vastleggen in de sessiontijdlijn
$session->rpc()->log()->log(new LogRequest(message: 'Verwerking gestart'));
$session->rpc()->log()->log(new LogRequest(message: 'Hoog schijfgebruik', level: LogLevel::WARNING));
$session->rpc()->log()->log(new LogRequest(message: 'Er is een fout opgetreden', level: LogLevel::ERROR));
$session->rpc()->log()->log(new LogRequest(message: 'Debuginformatie', ephemeral: true));

// shell: shellcommando's uitvoeren binnen de session
$result = $session->rpc()->shell()->exec(new ShellExecRequest(command: 'ls -la'));
// Gebruik $result->processId om de proces-ID op te halen voor kill of het volgen van de output

$session->rpc()->shell()->exec(new ShellExecRequest(
    command: 'npm test',
    cwd: '/path/to/project',
    timeout: 60000, // milliseconden
));

// Een draaiend shellproces stoppen
$session->rpc()->shell()->kill(new ShellKillRequest(
    processId: $result->processId,
    signal: 'SIGTERM', // SIGTERM (standaard), SIGKILL, SIGINT
));

// usage (experimenteel: gebruiksstatistieken van de session)
$metrics = $session->rpc()->usage()->getMetrics();
// $metrics->totalPremiumRequestCost - totale kosten van premium requests
// $metrics->totalUserRequests - totaal aantal gebruikersrequests
// $metrics->codeChanges - metrics van codewijzigingen (toegevoegde regels, verwijderde regels, gewijzigde bestanden)
// $metrics->modelMetrics - tokengebruik en aantal requests per model
// $metrics->currentModel - identifier van het huidige model

// auth: de authenticatiestatus van de session ophalen
$status = $session->rpc()->auth()->getStatus();
// $status->isAuthenticated - of er is geauthenticeerd
// $status->authType - authenticatietype (AuthInfoType enum: gh-cli, token, env, enz.)
// $status->login - GitHub-loginnaam
// $status->host - GitHub-host
// $status->copilotPlan - Copilot-plan (individual, business, enz.)
// $status->statusMessage - bericht over de authenticatiestatus
```

## SessionFS-callbacktypes

Er zijn callbacktypes (Request/Result) gedefinieerd voor sessionscoped bestandssysteemoperaties. Dit zijn de request-/responsetypes voor wanneer de Copilot CLI een callback naar de client doet.

| Typeklasse                                                             | Doel                               |
| ---------------------------------------------------------------------- | ---------------------------------- |
| `SessionFsReadFileRequest` / `SessionFsReadFileResult`                 | Bestand lezen                      |
| `SessionFsWriteFileRequest`                                            | Bestand schrijven                  |
| `SessionFsAppendFileRequest`                                           | Aan bestand toevoegen              |
| `SessionFsExistsRequest` / `SessionFsExistsResult`                     | Controleren of een bestand bestaat |
| `SessionFsStatRequest` / `SessionFsStatResult`                         | Bestandsmetadata ophalen           |
| `SessionFsMkdirRequest`                                                | Directory aanmaken                 |
| `SessionFsReaddirRequest` / `SessionFsReaddirResult`                   | Directoryoverzicht                 |
| `SessionFsReaddirWithTypesRequest` / `SessionFsReaddirWithTypesResult` | Getypeerd directoryoverzicht       |
| `SessionFsRmRequest`                                                   | Bestand/directory verwijderen      |
| `SessionFsRenameRequest`                                               | Bestand/directory hernoemen        |

Deze typeklassen staan in `src/Types/Rpc/`.

## Argumenten opgeven als array

Voor zowel argumenten als returnwaarden worden speciale klassen gebruikt, maar argumenten kun je ook als array opgeven.

```php theme={null}
$session->rpc()->mode()->set(['mode' => 'plan']);
```

## Testen

Mocken met `Copilot::fake()` werkt hier niet; mock daarom met `Copilot::expects('client')` of `Copilot::expects('start')`.

<Info>
  Raadpleeg de [GitHub-repository](https://github.com/invokable/laravel-copilot-sdk) voor de meest actuele informatie.
</Info>


## Related topics

- [Remote sessions](/nl/packages/laravel-copilot-sdk/remote-sessions.md)
- [Tools](/nl/packages/laravel-copilot-sdk/tools.md)
- [Laravel AI-agents ondersteunen nu MCP-servers](/nl/blog/ai-sdk-mcp-client.md)
- [Streaming events](/nl/packages/laravel-copilot-sdk/streaming-events.md)
- [ForwardsCalls-trait](/nl/advanced/forwards-calls.md)