RPC (Remote Procedure Call)

use Revolution\Copilot\Facades\Copilot;
use Revolution\Copilot\Types\Rpc\SecretsAddFilterValuesRequest;

$result = Copilot::client()->rpc()->secrets()->addFilterValues(
    new SecretsAddFilterValuesRequest(values: [$accessToken]),
);
// $result->ok

// Je kunt ook een array doorgeven
Copilot::client()->rpc()->secrets()->addFilterValues([
    'values' => [$accessToken],
]);

use Revolution\Copilot\Facades\Copilot;
use Revolution\Copilot\Types\Rpc\KerberosAuthSetProviderRequest;

Copilot::client()->rpc()->kerberosAuth()->setProvider(
    new KerberosAuthSetProviderRequest(mode: 'fallback', scope: 'connection'),
);

use Revolution\Copilot\Facades\Copilot;
use Revolution\Copilot\Types\Rpc\AgentRegistryEnsureDirRequest;
use Revolution\Copilot\Types\Rpc\AgentRegistryListEntriesRequest;
use Revolution\Copilot\Types\Rpc\AgentRegistryRemoveEntryRequest;
use Revolution\Copilot\Types\Rpc\RuntimeOpenBrowserRequest;
use Revolution\Copilot\Types\Rpc\SandboxPathGrantWarningParams;

$rpc = Copilot::client()->rpc();
$homeDir = '/home/user';

$registry = $rpc->agentRegistry();
$registry->ensureDir(new AgentRegistryEnsureDirRequest(homeDir: $homeDir));
$entries = $registry->listEntries(new AgentRegistryListEntriesRequest(homeDir: $homeDir));
$registry->removeEntry(new AgentRegistryRemoveEntryRequest(
    homeDir: $homeDir,
    pid: 1234,
));

$rpc->runtime()->openBrowser(new RuntimeOpenBrowserRequest(
    url: 'https://example.com/authorize',
));
$rpc->tools()->largeOutput()->cleanup();

$warning = $rpc->sandbox()->getPathGrantWarning(new SandboxPathGrantWarningParams(
    resolvedPath: '/workspace/project',
    readOnly: false,
));

use Revolution\Copilot\Facades\Copilot;
use Revolution\Copilot\Enums\TokenPriceUnit;
use Revolution\Copilot\Types\Rpc\ModelsListTokenPriceUnitsRequest;
use Revolution\Copilot\Types\Rpc\ModelList;

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

// Vrijwel hetzelfde als de oorspronkelijke listModels()
// De returnwaarde is een array van ModelInfo
Copilot::client()->listModels();

use Illuminate\Http\Client\Response;
use Revolution\Copilot\Enums\CatalogCandidateKind;
use Revolution\Copilot\Enums\CatalogCapability;
use Revolution\Copilot\Enums\CatalogSelectionDecision;
use Revolution\Copilot\Enums\CatalogTrustTier;
use Revolution\Copilot\Enums\EventsReadDirection;
use Revolution\Copilot\Enums\McpInstallationSecretStorage;
use Revolution\Copilot\Enums\OptionsUpdateToolFilterPrecedence;
use Revolution\Copilot\Enums\SkillInstallationManagementOutcomeKind;
use Revolution\Copilot\Enums\SkillInstallationManagementResultKind;
use Revolution\Copilot\Enums\AzureMlRegistry;
use Revolution\Copilot\Types\Rpc\AzureMlAcquireFamilyRequest;
use Revolution\Copilot\Types\Rpc\AzureMlCancelRequest;
use Revolution\Copilot\Types\Rpc\AzureMlCatalogRequest;
use Revolution\Copilot\Types\Rpc\AzureMlDiscardRequest;
use Revolution\Copilot\Types\Rpc\AzureMlDownloadRequest;
use Revolution\Copilot\Types\Rpc\AzureMlLatestRequest;
use Revolution\Copilot\Types\Rpc\AzureMlReleaseFamilyRequest;
use Revolution\Copilot\Types\Rpc\AzureMlResolveRequest;
use Revolution\Copilot\Types\Rpc\AzureMlStatusRequest;
use Revolution\Copilot\Types\Rpc\AgentsDiscoverRequest;
use Revolution\Copilot\Types\Rpc\AgentsGetDiscoveryPathsRequest;
use Revolution\Copilot\Types\Rpc\CatalogClientContract;
use Revolution\Copilot\Types\Rpc\CatalogGetGeneratedFeedRequest;
use Revolution\Copilot\Types\Rpc\CatalogGetSavedFeedRequest;
use Revolution\Copilot\Types\Rpc\CatalogMaterializationReference;
use Revolution\Copilot\Types\Rpc\CatalogSearchRequest;
use Revolution\Copilot\Types\Rpc\CatalogSelectionRequest;
use Revolution\Copilot\Types\Rpc\ExtensionLaunchProfile;
use Revolution\Copilot\Types\Rpc\ExtensionLaunchProviderResolveRequest;
use Revolution\Copilot\Types\Rpc\ExtensionLaunchProviderResolveResult;
use Revolution\Copilot\Types\Rpc\HooksDiscoverRequest;
use Revolution\Copilot\Types\Rpc\InstructionsDiscoverRequest;
use Revolution\Copilot\Types\Rpc\InstructionsGetDiscoveryPathsRequest;
use Revolution\Copilot\Types\Rpc\McpApplyInstallRequest;
use Revolution\Copilot\Types\Rpc\McpApplyUninstallRequest;
use Revolution\Copilot\Types\Rpc\McpInstallationOperationRequest;
use Revolution\Copilot\Types\Rpc\McpInstallationsRequest;
use Revolution\Copilot\Types\Rpc\McpPlanUninstallRequest;
use Revolution\Copilot\Types\Rpc\McpPrepareInstallRequest;
use Revolution\Copilot\Types\Rpc\McpRegistryCancelRequest;
use Revolution\Copilot\Types\Rpc\McpRegistrySearchRequest;
use Revolution\Copilot\Types\Rpc\McpServerCardReference;
use Revolution\Copilot\Types\Rpc\McpShouldExcludeGitHubToolsRequest;
use Revolution\Copilot\Types\Rpc\PluginsBuiltinSetRequest;
use Revolution\Copilot\Types\Rpc\PluginsDisableRequest;
use Revolution\Copilot\Types\Rpc\PluginsEnableRequest;
use Revolution\Copilot\Types\Rpc\PluginsInstallRequest;
use Revolution\Copilot\Types\Rpc\PluginsMarketplacesAddRequest;
use Revolution\Copilot\Types\Rpc\PluginsMarketplacesBrowseRequest;
use Revolution\Copilot\Types\Rpc\PluginsMarketplacesRefreshRequest;
use Revolution\Copilot\Types\Rpc\PluginsMarketplacesRemoveRequest;
use Revolution\Copilot\Types\Rpc\PluginsUninstallRequest;
use Revolution\Copilot\Types\Rpc\PluginsUpdateRequest;
use Revolution\Copilot\Types\Rpc\SessionsListRequest;
use Revolution\Copilot\Types\Rpc\SessionsOpenCreateRequest;
use Revolution\Copilot\Enums\SessionsOpenStatus;
use Revolution\Copilot\Types\SessionConfig;
use Revolution\Copilot\Types\Rpc\SessionsPruneOldRequest;
use Revolution\Copilot\Types\Rpc\SessionsReadPersistedEventsRequest;
use Revolution\Copilot\Types\Rpc\SkillApplyInstallRequest;
use Revolution\Copilot\Types\Rpc\SkillApplyUninstallRequest;
use Revolution\Copilot\Types\Rpc\SkillInstallationOperationRequest;
use Revolution\Copilot\Types\Rpc\SkillInstallationsRequest;
use Revolution\Copilot\Types\Rpc\SkillPlanInstallRequest;
use Revolution\Copilot\Types\Rpc\SkillPlanInstallFromReferenceRequest;
use Revolution\Copilot\Types\Rpc\SkillPlanUninstallRequest;
use Revolution\Copilot\Types\Rpc\SkillSetEnabledRequest;
use Revolution\Copilot\Types\Rpc\SkillsGetDiscoveryPathsRequest;
use Revolution\Copilot\Types\Rpc\UIEphemeralQueryRequest;
use Revolution\Copilot\Types\SessionListFilter;
use Revolution\Copilot\Support\CopilotRequestContext;
use Revolution\Copilot\Support\CopilotRequestHandler;

Copilot::client()->rpc()->ping();

// models
Copilot::client()->rpc()->models()->list();
// Ophalen met een GitHub-token per sessie
Copilot::client()->rpc()->models()->list(new ModelsListRequest(gitHubToken: $token));
// De eenheden van tokenprijzen per model ophalen. Geef dezelfde accountselectie door als bij models.list
$priceUnits = Copilot::client()->rpc()->models()->listTokenPriceUnits(
    new ModelsListTokenPriceUnitsRequest(gitHubToken: $token),
);
// $priceUnits->units bevat een modelId en een unit van het type TokenPriceUnit|string
foreach ($priceUnits->units as $priceUnit) {
    if ($priceUnit->unit === TokenPriceUnit::NanoAiu) {
        // Deel door 1.000.000.000 om nano-AIU om te rekenen naar AI Credits
    }
}
// Ingebouwde modelcatalogus
Copilot::client()->rpc()->models()->getBuiltInCatalog();

// Beheer van lokale Azure ML-modellen (experimental)
$azureMl = Copilot::client()->rpc()->azureMl();
$catalog = $azureMl->catalog(new AzureMlCatalogRequest(includeDev: false));
$latest = $azureMl->latest(new AzureMlLatestRequest(
    registry: AzureMlRegistry::AzureMl,
    name: 'phi',
));
$resolved = $azureMl->resolve(new AzureMlResolveRequest(
    registry: AzureMlRegistry::AzureMl,
    name: $latest->name,
    version: $latest->version,
));

// requestId en leaseId zijn gekoppeld aan deze SDK-verbinding; hergebruik ze niet in een andere Client
$lease = $azureMl->acquireFamily(new AzureMlAcquireFamilyRequest(
    registry: AzureMlRegistry::AzureMl,
    name: $latest->name,
));

try {
    $download = $azureMl->download(new AzureMlDownloadRequest(
        requestId: 'download-1',
        registry: AzureMlRegistry::AzureMl,
        name: $latest->name,
        version: $latest->version,
        destination: 'models/phi/'.$latest->version,
        leaseId: $lease->leaseId,
    ));
} finally {
    $azureMl->releaseFamily(new AzureMlReleaseFamilyRequest(
        leaseId: $lease->leaseId,
        registry: AzureMlRegistry::AzureMl,
        name: $latest->name,
    ));
}

// download() wacht tot het klaar is. Voortgang controleren of annuleren tijdens de verwerking
// doe je vanuit bijvoorbeeld een andere Fiber met dezelfde verbinding ($azureMl)
// $status = $azureMl->status(new AzureMlStatusRequest(requestId: 'download-1'));
// $cancelled = $azureMl->cancel(new AzureMlCancelRequest(requestId: 'download-1'));
// De bool van cancel() geeft aan dat het annuleringsverzoek is geaccepteerd; controleer de voltooide opschoning via download()

// Een inactieve versie verwijderen
$azureMl->discard(new AzureMlDiscardRequest(destination: 'models/phi/previous-version'));

// De typen van resolve() en download() hebben geen apart veld voor ondertekende URL's
// download() heeft standaard geen time-out. Geef een aantal seconden op als tweede argument

// Lijst met ingebouwde slash-commando's die in nieuwe sessies beschikbaar zijn (experimental)
Copilot::client()->rpc()->commands()->list();

// Hooks verkennen vóór het starten van een sessie (experimental)
Copilot::client()->rpc()->hooks()->discover(new HooksDiscoverRequest(
    projectPaths: ['/path/to/project'],
));

// Sandboxondersteuning van de host (experimental)
$hostSupport = Copilot::client()->rpc()->sandbox()->getHostSupport();
// $hostSupport->supported, $hostSupport->reason, $hostSupport->capabilities

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

// account
Copilot::client()->rpc()->account()->getQuota();
// Ophalen met een GitHub-token per sessie
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']),
));
// args is optioneel
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 instelling)
Copilot::client()->rpc()->mcp()->enable(new McpConfigEnableRequest(names: ['my-server']));
Copilot::client()->rpc()->mcp()->disable(new McpConfigDisableRequest(names: ['my-server']));
// De in-memory cache wissen (bij de volgende keer laden wordt opnieuw van schijf gelezen)
Copilot::client()->rpc()->mcp()->reload();

// Zoeken in het MCP-register (experimental/internal)
// $authInfo is JSON-authenticatie-informatie die door de host is voorbereid. De SDK interpreteert de inhoud niet.

$registry = Copilot::client()->rpc()->mcp()->registry();
$requestId = $registry->allocateRequestId()->requestId;
$servers = $registry->search(new McpRegistrySearchRequest(
    requestId: $requestId,
    authInfo: $authInfo, // Authenticatie-informatie van de host. De SDK interpreteert de inhoud niet.
    query: 'database',
    limit: 20,
));
// $servers->servers bevat de serverdata uit het register (bewaard zonder de vorm te interpreteren)
// Ongebruikte gereserveerde ID's kun je vrijgeven. Een lopende zoekopdracht annuleer je door cancel() vanuit een ander proces aan te roepen.
$unusedRequestId = $registry->allocateRequestId()->requestId;
$cancelResult = $registry->cancel(new McpRegistryCancelRequest(requestId: $unusedRequestId));
// Bij het vrijgeven van een ongebruikte ID is canceled false. Alleen true als een lopende zoekopdracht is gestopt.

// Installeren / verwijderen via de MCP-catalogus (experimental)
// Het resultaat is een associatieve array van een gediscrimineerde union met kind. Controleer kind voordat je de afzonderlijke velden gebruikt.

$mcp = Copilot::client()->rpc()->mcp();
$contract = new CatalogClientContract(
    protocolVersion: 1,
    requiredCapabilities: ['mcp-server-card', 'mcp-install-planning'],
);

// $candidateHandle, $searchId en $cardReference haal je uit de zoekresultaten van de catalogus.
// $sessionId is een sessie-ID die al met deze Client verbonden is.
$planned = $mcp->planInstall([
    'contract' => $contract->toArray(),
    'source' => ['kind' => 'candidate', 'candidateHandle' => $candidateHandle, 'searchId' => $searchId],
]);

if (($planned['kind'] ?? null) === 'planned') {
    $plan = $planned['plan'];
    $prepared = $mcp->prepareInstall(new McpPrepareInstallRequest(
        contract: $contract,
        planHandle: $plan['planHandle'],
        choiceId: $plan['transportChoices'][0]['choiceId'],
        inputs: [],
        policySessionId: $sessionId,
        secrets: [],
        secretStorage: McpInstallationSecretStorage::Keychain,
        source: McpServerCardReference::fromArray($cardReference),
    ));

    // Tijdens applyInstall wordt de installation_confirmation_handler aangeroepen die bij het aanmaken van de client is ingesteld.
    if (($prepared['kind'] ?? null) === 'outcome'
        && ($prepared['outcome']['kind'] ?? null) === 'install-prepared') {
        $applied = $mcp->applyInstall(new McpApplyInstallRequest(
            contract: $contract,
            operationId: $prepared['outcome']['operation']['operationId'],
            policySessionId: $sessionId,
        ));
    }
}

// Lijst met installaties in eigendom en herstel van onvoltooide bewerkingen
$installations = $mcp->installations();
$installations->list(new McpInstallationsRequest(contract: $contract, policySessionId: $sessionId));
$installations->recover(new McpInstallationsRequest(contract: $contract, policySessionId: $sessionId));
$installations->status(new McpInstallationOperationRequest($contract, $operationId));
$installations->cancel(new McpInstallationOperationRequest($contract, $operationId));

// Voor verwijderen plan je met een installationId in eigendom en pas je de teruggegeven planHandle toe.
$uninstallPlan = $mcp->planUninstall(new McpPlanUninstallRequest(
    contract: $contract,
    installationId: $installationId,
    policySessionId: $sessionId,
));
if (($uninstallPlan['kind'] ?? null) === 'outcome'
    && ($uninstallPlan['outcome']['kind'] ?? null) === 'uninstall-planned') {
    $mcp->applyUninstall(new McpApplyUninstallRequest(
        contract: $contract,
        planHandle: $uninstallPlan['outcome']['plan']['planHandle'],
        policySessionId: $sessionId,
    ));
}

// Bepalen of GitHub MCP-tools uitgesloten kunnen worden (experimental/internal)

$exclude = Copilot::client()->rpc()->mcp()->shouldExcludeGitHubTools(
    new McpShouldExcludeGitHubToolsRequest(
        availableTools: ['builtin:bash'],
        excludedTools: [],
        toolFilterPrecedence: OptionsUpdateToolFilterPrecedence::Available,
    ),
)->excludeGhReplaceableTools;

// user settings (gebruikersinstellingen)
// De huidige CLI heeft geen user.settings.reload-RPC. get() werkt op settings.json.
Copilot::client()->rpc()->userSettings()->set(['settings' => ['theme' => 'dark']]); // geen returnwaarde

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

// llmInference (experimental: HTTP-verzoeken naar de modellaag onderscheppen)
$client = Copilot::client([
    'request_handler' => new class extends CopilotRequestHandler
    {
        public function sendRequest(CopilotRequestContext $context, string $method, string $body): Response
        {
            $context->url = 'https://proxy.example.com/v1/chat/completions';
            $context->headers['X-Request-Source'] = ['laravel'];

            return parent::sendRequest($context, $method, $body);
        }
    },
]);

// Bij het opstarten wordt llmInference.setProvider verzonden en ontvang je httpRequestStart / httpRequestChunk.
// Een handler die sendRequest niet overschrijft, stuurt HTTP/SSE transparant door met de Laravel HTTP Client.
// Geef je een Closure op, dan retourneert die een Response in de vorm fn (CopilotRequestContext $context, string $method, string $body): Response.
// request_handler is experimental. WebSocket-transport wordt niet ondersteund en levert een foutantwoord gelijkwaardig aan 501 op.

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

// Clientoptie die bepaalt hoe extensies worden gestart (antwoord binnen 15 seconden)
$client = Copilot::client([
    'extensionLaunchProvider' => fn (ExtensionLaunchProviderResolveRequest $request) => new ExtensionLaunchProviderResolveResult(
        launch: new ExtensionLaunchProfile(
            executable: '/usr/bin/node',
            args: [$request->modulePath],
        ),
    ),
]);
// Retourneer null als er geen passende startmethode is.
// fn (ExtensionLaunchProviderResolveRequest $request) => null

$sessions = Copilot::client()->rpc()->sessions();

// sessions (experimental: persistente sessies opvragen en beheren)

// sessions.open kiest met `kind` tussen create, resume, resumeLast, attach, remote-/cloudverbinding of handoff.
$opened = $sessions->open(new SessionsOpenCreateRequest(
    options: new SessionConfig(sessionId: 'new-session', model: 'gpt-5'),
));
if ($opened->status === SessionsOpenStatus::Created) {
    echo $opened->sessionId;
}
// Je kunt ook een array doorgeven. Geef bij hervatten sessionId op het hoogste niveau van de variant op.
$resumed = $sessions->open(['kind' => 'resume', 'sessionId' => 'existing-session']);
// Retourneert SessionsOpenResult. Als de status not_found is, is er geen sessionId.
// sessionApi, onTaskCreated, onProgress en onConfirm zijn alleen in-process en worden niet in de wire-payload opgenomen.

$listed = $sessions->list(new SessionsListRequest(
    source: 'local',
    metadataLimit: 50,
    filter: new SessionListFilter(cwd: '/path/to/project'),
));
// Onderscheid local / remote sessies met isRemote van elke SessionMetadata
foreach ($listed->sessions as $session) {
    echo $session->sessionId;
}

$sessions->findByTaskId(['taskId' => 'task-id']);
$sessions->findByPrefix(['prefix' => 'session-id-prefix']);
$sessions->getLastForContext(['context' => ['cwd' => '/path/to/project']]);
$sizes = $sessions->getSizes(); // $sizes->sizes is session ID => aantal bytes
$inUse = $sessions->checkInUse(['sessionIds' => ['session-id']]);
$deleted = $sessions->bulkDelete(['sessionIds' => ['session-id']]);

// Een actieve sessie sluiten (de geschiedenis wordt niet verwijderd)
$sessions->close(['sessionId' => 'session-id']);

// Openstaande events naar schijf schrijven
$sessions->save(['sessionId' => 'session-id']);

// De in-use lock van een sessie die dit proces vasthoudt expliciet vrijgeven
$sessions->releaseLock(['sessionId' => 'session-id']);

// reloadPluginHooks laadt user/plugin hooks opnieuw.
// Vóór de folder trust-controle worden repo hooks uitgesteld en na bevestiging van het vertrouwen alsnog geladen.
$sessions->reloadPluginHooks([
    'sessionId' => 'session-id',
    'deferRepoHooks' => true,
]);
$loadedHooks = $sessions->loadDeferredRepoHooks(['sessionId' => 'session-id']);
// $loadedHooks->startupPrompts en $loadedHooks->hookCount

// De manager-brede aanvullende pluginconfiguratie vervangen (leeg array om te wissen)
$sessions->setAdditionalPlugins(['plugins' => []]);

// summary / context van local session metadata aanvullen
$enriched = $sessions->enrichMetadata([
    'sessions' => [[
        'sessionId' => 'session-id',
        'startTime' => '2026-10-17T09:00:00Z',
        'modifiedTime' => '2026-10-17T09:00:00Z',
        'isRemote' => false,
    ]],
]);

// close() voert shutdown uit, slaat events op, geeft de lock vrij en ruimt de active session op,
// maar verwijdert de persisted history niet. $session->disconnect() geeft via session.detach de
// verbinding met deze SDK en de in-memory resources aan de PHP-kant vrij. Gebruik bulkDelete() om persistente data te verwijderen.

// Persistente events pagineren met een cursor, zonder de sessie te openen
$cursor = null;
do {
    $page = $sessions->readPersistedEvents(new SessionsReadPersistedEventsRequest(
        sessionId: 'session-id',
        cursor: $cursor,
        max: 100,
        direction: EventsReadDirection::FORWARD,
    ));

    foreach ($page->events as $event) {
        // Event verwerken
    }

    $cursor = $page->cursor;
} while ($page->hasMore);

// dryRun verwijdert niets en geeft kandidaten en een schatting terug. Geef dryRun: false op om echt te verwijderen
$preview = $sessions->pruneOld(new SessionsPruneOldRequest(
    olderThanDays: 30,
    dryRun: true,
));

// sessions.fork
$sessions->fork(new SessionsForkRequest(
    sessionId: 'source-session-id',
    toEventId: 'evt-boundary', // Optioneel: alleen events vóór deze ID opnemen
));

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

// Uit te schakelen skills instellen
Copilot::client()->rpc()->skills()->config()->setDisabledSkills(
    new SkillsConfigSetDisabledSkillsRequest(disabledSkills: ['skill-name'])
);

// Afzonderlijke skills in- of uitschakelen
Copilot::client()->rpc()->skills()->config()->setSkillDisabled(
    new SkillsConfigSetSkillDisabledRequest(name: 'skill-name', disabled: true)
);

// Een skillkandidaat selecteren met catalog.search → catalog.select (experimental)

$contract = new CatalogClientContract(1, ['catalog-selection', 'ai-skill-installation']);
$catalog = Copilot::client()->rpc()->catalog();
$search = $catalog->search(new CatalogSearchRequest(
    contract: $contract,
    query: 'code review skill',
    kinds: [CatalogCandidateKind::AiSkill],
));
$selection = $catalog->select(new CatalogSelectionRequest(
    contract: $contract,
    sessionId: $sessionId,
    selectionRef: $search['candidates'][0]['selectionRef'],
    outcome: CatalogSelectionDecision::Selected,
));

// Voor een category filter vraag je catalog-search-categories aan
$categoryContract = new CatalogClientContract(3, [
    CatalogCapability::CatalogSearchCategories->value,
]);
$categorySearch = $catalog->search(new CatalogSearchRequest(
    contract: $categoryContract,
    query: 'design tools',
    categories: ['design', 'test'],
));
// Als je policySessionId opgeeft, vraag je in het contract ook credential-required en session-bound aan,
// en wordt alleen aan een bestaande attached session gebonden. Er wordt nooit een sessie aangemaakt of hervat.

// Opgeslagen en gegenereerde catalog feed (credential required)
$feedContract = new CatalogClientContract(3, [
    CatalogCapability::CatalogFeeds->value,
    CatalogCapability::CatalogSearchCredentialRequired->value,
]);
$savedFeed = $catalog->getSavedFeed(new CatalogGetSavedFeedRequest(
    contract: $feedContract,
    feedId: 'opaque-feed-id',
    trustTiers: [CatalogTrustTier::T1],
));

// Om aan een bestaande attached session te binden, vraag je ook de session-bound capability aan
$sessionFeedContract = new CatalogClientContract(3, [
    CatalogCapability::CatalogFeeds->value,
    CatalogCapability::CatalogSearchCredentialRequired->value,
    CatalogCapability::CatalogSearchSessionBound->value,
]);
$generatedFeed = $catalog->getGeneratedFeed(new CatalogGetGeneratedFeedRequest(
    contract: $sessionFeedContract,
    strategy: 'telemetry',
    key: 'popular',
    policySessionId: $sessionId,
    trustTiers: [CatalogTrustTier::T1, CatalogTrustTier::T2],
));
// entries behouden de volgorde van de feed. Items die niet bij de trust tier passen behouden hun positie als filtered,
// en entries die niet getoond kunnen worden, komen terug als unavailable met een reason.
// Als er geen feed is: kind=unavailable, reason=feed-not-found. Authenticatie-, onderhandelings- en beleidsweigeringen
// komen elk terug als getypeerd resultaat; catalog feed-RPC's voeren geen installatie of configuratie uit.

// Installatieplan voor een skill maken en toepassen

$skills = Copilot::client()->rpc()->skills();
if ($selection['kind'] === 'selected') {
    $planned = $skills->planInstall(new SkillPlanInstallRequest(
        contract: $contract,
        candidateHandle: $selection['candidateHandle'],
        policySessionId: $sessionId,
    ));
    if ($planned->kind === SkillInstallationManagementResultKind::Outcome
        && $planned->outcome?->kind === SkillInstallationManagementOutcomeKind::InstallPlanned) {
        // applyInstall() wordt toegepast na bevestiging via installations.confirm
        $result = $skills->applyInstall(new SkillApplyInstallRequest(
            contract: $contract,
            planHandle: $planned->outcome->plan['planHandle'],
            policySessionId: $sessionId,
        ));
    }
}

// Een skillinstallatie plannen op basis van een materialisation reference van Agent Finder
$referenceContract = new CatalogClientContract(3, [
    'skill-confirmed-installation',
    'skill-reference-installation',
]);
$referencePlan = $skills->planInstallFromReference(new SkillPlanInstallFromReferenceRequest(
    contract: $referenceContract,
    reference: new CatalogMaterializationReference(
        resourceId: '12345',
        revisionId: '67890',
        schemaVersion: '1.0.0',
        descriptorDigest: 'sha256:aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',
        bundleDigest: 'sha256:bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb',
    ),
    policySessionId: $sessionId,
));
// Bij succes geldt $referencePlan->kind === SkillInstallationManagementResultKind::Outcome
// en $referencePlan->outcome->kind === SkillInstallationManagementOutcomeKind::InstallPlanned.
// Het plannen zelf heeft geen bijwerkingen: de descriptor wordt opgehaald bij de vaste Agent Finder-authority
// en de digests van descriptor en bundle worden vergeleken. Controleer de inhoud en voltooi de bestaande bevestigingsflow voordat je applyInstall() aanroept.
// invalid-reference, descriptor-not-found, descriptor-withdrawn, digest-mismatch en
// unsupported-resource worden teruggegeven als weigeringsreden in het planresultaat.
// De GitHub-weigeringsredenen source-rate-limited, no-credential en credential-rejected worden
// onderscheiden met SkillInstallationFailureReason; retryAfterSeconds wordt alleen bij source-rate-limited teruggegeven.
// De message van network-failure is een veilige omschrijving zonder URL, zoekopdracht, handle of secret.

// Geïnstalleerde skills en lopende bewerkingen
$installations = $skills->installations();
$owned = $installations->list(new SkillInstallationsRequest($contract, $sessionId));
$pending = $installations->recover(new SkillInstallationsRequest($contract, $sessionId));
$status = $installations->status(new SkillInstallationOperationRequest($contract, 'operation-id'));
$cancelled = $installations->cancel(new SkillInstallationOperationRequest($contract, 'operation-id'));
$enabled = $installations->setEnabled(new SkillSetEnabledRequest(
    contract: $contract,
    installationId: 'installation-id',
    enabled: true,
    policySessionId: $sessionId,
));

// Ook bij verwijderen eerst het plan controleren en daarna toepassen
$removalPlan = $skills->planUninstall(new SkillPlanUninstallRequest(
    contract: $contract,
    installationId: 'installation-id',
    policySessionId: $sessionId,
));
$removed = $skills->applyUninstall(new SkillApplyUninstallRequest(
    contract: $contract,
    planHandle: $removalPlan['planHandle'],
    policySessionId: $sessionId,
));

// skills: mappen ophalen waarin skills kunnen worden aangemaakt (experimental)
// Lijst met mappen waarin de runtime geplaatste skills herkent

$result = Copilot::client()->rpc()->skills()->getDiscoveryPaths();
// $result->paths is een array van SkillDiscoveryPath
// $result->paths[0]->path - mappad
// $result->paths[0]->scope - scope (user, project, plugin)
// $result->paths[0]->preferredForCreation - of dit de aanbevolen map voor nieuwe skills is
// Optioneel de scope beperken
$result = Copilot::client()->rpc()->skills()->getDiscoveryPaths(
    new SkillsGetDiscoveryPathsRequest(scope: 'project')
);

// plugins (pluginbeheer op serverniveau)

$plugins = Copilot::client()->rpc()->plugins();
$result = $plugins->list(); // de returnwaarde is PluginList
$installed = $plugins->install(new PluginsInstallRequest(source: 'eslint@official'));
$plugins->uninstall(new PluginsUninstallRequest(name: 'eslint@official'));
$plugins->update(new PluginsUpdateRequest(name: 'eslint@official'));
$plugins->updateAll();
$plugins->enable(new PluginsEnableRequest(names: ['eslint@official']));
$plugins->disable(new PluginsDisableRequest(names: ['eslint@official']));

// Mappen voor ingebouwde plugins instellen
$plugins->builtin()->set(new PluginsBuiltinSetRequest(paths: ['/opt/copilot/plugins']));

// Mappen die voor alle sessies gelden, kun je in de clientconfiguratie opgeven;
// Client::start() registreert ze dan automatisch vóór het aanmaken van de eerste sessie
// config/copilot.php: 'builtin_plugin_directories' => ['/opt/copilot/plugins']

// Marketplacebeheer
$marketplaces = $plugins->marketplaces();
$marketplaces->list();
$marketplaces->add(new PluginsMarketplacesAddRequest(source: 'github/copilot-plugins'));
$marketplaces->remove(new PluginsMarketplacesRemoveRequest(name: 'official', force: true));
$marketplaces->browse(new PluginsMarketplacesBrowseRequest(name: 'official'));
$marketplaces->refresh(new PluginsMarketplacesRefreshRequest(name: 'official'));

// agents (experimental: beheer van aangepaste agents)
// Aangepaste agents verkennen

$result = Copilot::client()->rpc()->agents()->discover();
// $result->agents is een array van AgentInfo
$result = Copilot::client()->rpc()->agents()->discover(new AgentsDiscoverRequest(
    projectPaths: ['/path/to/project'],
    excludeHostAgents: true,
));

// Mappen ophalen waarin agents kunnen worden aangemaakt (experimental)

$result = Copilot::client()->rpc()->agents()->getDiscoveryPaths();
// $result->paths is een array van AgentDiscoveryPath
// $result->paths[0]->path - mappad
// $result->paths[0]->scope - scope (user, project, plugin)
// $result->paths[0]->preferredForCreation - of dit de aanbevolen map voor nieuwe agents is
$result = Copilot::client()->rpc()->agents()->getDiscoveryPaths(
    new AgentsGetDiscoveryPathsRequest(scope: 'user')
);

// instructions (experimental: beheer van instructies)
// Instructies verkennen

$result = Copilot::client()->rpc()->instructions()->discover();
// $result->sources is een array van InstructionSource
$result = Copilot::client()->rpc()->instructions()->discover(
    new InstructionsDiscoverRequest(projectPaths: ['/path/to/project'])
);

// Bestanden/mappen ophalen waarin instructies kunnen worden aangemaakt (experimental)

$result = Copilot::client()->rpc()->instructions()->getDiscoveryPaths();
// $result->paths is een array van InstructionDiscoveryPath
// $result->paths[0]->path - bestands-/mappad
// $result->paths[0]->location - locatie (user, repository, working-directory, plugin)
// $result->paths[0]->kind - soort (file, directory)
// $result->paths[0]->preferredForCreation - of dit aanbevolen is voor nieuwe instructies
$result = Copilot::client()->rpc()->instructions()->getDiscoveryPaths(
    new InstructionsGetDiscoveryPathsRequest(location: 'repository')
);

// extensions (experimental: beheer van persistent opgeslagen extensies)
$result = Copilot::client()->rpc()->extensions()->discover();
Copilot::client()->rpc()->extensions()->enable(['ids' => ['user:demo']]);
Copilot::client()->rpc()->extensions()->disable(['ids' => ['plugin:demo']]);

// environments (experimental: GitHub Mission Control-omgevingen zoeken, ophalen en verwijderen)
$result = Copilot::client()->rpc()->environments()->list(['kind' => 'user-local']);
// $result->environments is een array van GitHubEnvironment
$env = Copilot::client()->rpc()->environments()->get(['environmentId' => 'env-id']);
Copilot::client()->rpc()->environments()->delete(['environmentId' => 'env-id']);

use Revolution\Copilot\Enums\CatalogReferenceInstallationResultKind;
use Revolution\Copilot\Enums\PluginInstallationManagementOutcomeKind;
use Revolution\Copilot\Types\Rpc\CatalogClientContract;
use Revolution\Copilot\Types\Rpc\PluginApplyInstallRequest;
use Revolution\Copilot\Types\Rpc\PluginPlanInstallRequest;

$contract = new CatalogClientContract(3, [
    'agent-plugin-confirmed-installation',
]);
$plugins = Copilot::client()->rpc()->plugins();

$planned = $plugins->planInstall(new PluginPlanInstallRequest(
    candidateHandle: $candidateHandle,
    contract: $contract,
    policySessionId: $sessionId,
));

if ($planned->kind === CatalogReferenceInstallationResultKind::Outcome
    && $planned->outcome?->kind === PluginInstallationManagementOutcomeKind::InstallPlanned) {
    $applied = $plugins->applyInstall(new PluginApplyInstallRequest(
        contract: $contract,
        planHandle: $planned->outcome->plan->planHandle,
        policySessionId: $sessionId,
    ));
}

use Revolution\Copilot\Enums\CatalogCapability;
use Revolution\Copilot\Enums\CatalogReferenceInstallationOutcomeKind;
use Revolution\Copilot\Enums\CatalogReferenceInstallationResultKind;
use Revolution\Copilot\Types\Rpc\CatalogClientContract;
use Revolution\Copilot\Types\Rpc\CatalogPlanInstallFromReferenceRequest;
use Revolution\Copilot\Types\Rpc\PluginApplyInstallRequest;

$referenceContract = new CatalogClientContract(3, [
    CatalogCapability::CatalogReferenceInstallation->value,
    CatalogCapability::AgentPluginConfirmedInstallation->value,
]);
$planned = Copilot::client()->rpc()->catalog()->planInstallFromReference(
    new CatalogPlanInstallFromReferenceRequest(
        contract: $referenceContract,
        policySessionId: $sessionId,
        reference: $reference,
    ),
);

$plugins = Copilot::client()->rpc()->plugins();
if ($planned->kind === CatalogReferenceInstallationResultKind::Outcome
    && $planned->outcome?->kind === CatalogReferenceInstallationOutcomeKind::PluginInstallPlanned) {
    $plugins->applyInstall(new PluginApplyInstallRequest(
        contract: $referenceContract,
        planHandle: $planned->outcome->plan->planHandle,
        policySessionId: $sessionId,
    ));
}

use Revolution\Copilot\Types\Rpc\ContentExclusionValidatePoliciesRequest;

$result = Copilot::client()->rpc()->contentExclusion()->validatePolicies(
    new ContentExclusionValidatePoliciesRequest(policiesJson: $policiesJson),
);
// $result->policies is het gevalideerde en genormaliseerde beleid

$managedSettings = $client->rpc()->managedSettings()->read();
$effective = $client->rpc()->managedSettings()->resolve([
    'selectionId' => 'selection-id',
    'workingDirectory' => '/path/to/project',
]);
$schema = $client->rpc()->managedSettings()->schema();
$validation = $client->rpc()->managedSettings()->validate(['content' => ['permissions' => []]]);
$preview = $client->rpc()->managedSettings()->compose(['layers' => [
    ['source' => 'device', 'settings' => ['permissions' => []]],
]]);
$client->rpc()->managedSettings()->clearCache();

$result = $client->rpc()->settings()->removeRawKey([
    'filePath' => '/path/to/settings.json',
    'rawKey' => 'misspelledKey',
]);
// $result->status is 'ok' of 'invalid'

$redacted = $client->rpc()->settings()->redactValueForDisplay([
    'value' => ['apiKey' => 'secret-value', 'name' => 'visible'],
    'basePath' => ['providers', 'openai'],
]);
// Geheime waarden in $redacted->value zijn vervangen door placeholders

$result = Copilot::client()->rpc()->host()->unpublishSession([
    'hostId' => 'host-1',
    'sessionId' => 'session-1',
]);
// $result->unpublished

Copilot::client()->rpc()->host()->dispose(['hostId' => 'host-1']);

use Revolution\Copilot\Types\Rpc\HostSetSessionCreationPolicyRequest;

Copilot::client()->rpc()->host()->setSessionCreationPolicy(
    new HostSetSessionCreationPolicyRequest(
        hostId: 'host-1',
        allowCreatingNewSessions: false,
    ),
);

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 ...');

    $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());
});

$state = $session->rpc()->autopilotObjective()->getState()->state;

if ($state !== null) {
    dump($state->objective, $state->status, $state->turnCount, $state->creditLimit);
}

$result = $session->rpc()->permissions()->clearResumeEscalation();
// $result->success

use Revolution\Copilot\Enums\DebugCollectLogsEntryKind;
use Revolution\Copilot\Enums\DebugCollectLogsRedaction;
use Revolution\Copilot\Types\Rpc\DebugCollectLogsDestination;
use Revolution\Copilot\Types\Rpc\DebugCollectLogsEntry;
use Revolution\Copilot\Types\Rpc\DebugCollectLogsRequest;

$result = $session->rpc()->debug()->collectLogs(new DebugCollectLogsRequest(
    destination: DebugCollectLogsDestination::archive('/tmp/copilot-debug.tgz', noOverwrite: true),
    additionalEntries: [
        new DebugCollectLogsEntry(
            kind: DebugCollectLogsEntryKind::File,
            path: '/var/log/my-app.log',
            bundlePath: 'application/my-app.log',
            redaction: DebugCollectLogsRedaction::PlainText,
            required: true,
        ),
    ],
));

use Revolution\Copilot\Types\Rpc\ContentExclusionCheckPathsRequest;

$result = $session->rpc()->contentExclusion()->checkPaths(
    new ContentExclusionCheckPathsRequest(paths: [
        '/workspace/private.txt',
        '/workspace/public.txt',
    ]),
);

if ($result->isExcluded('/workspace/private.txt')) {
    // Uitgesloten, of niet veilig te bepalen.
}

use Revolution\Copilot\Types\Rpc\MCPAppsDiagnoseRequest;
use Revolution\Copilot\Types\Rpc\MCPAppsListToolsRequest;
use Revolution\Copilot\Types\Rpc\McpAppsCallToolRequest;
use Revolution\Copilot\Types\Rpc\McpAppsReadResourceRequest;
use Revolution\Copilot\Types\Rpc\McpAppsSetHostContextDetails;
use Revolution\Copilot\Types\Rpc\McpAppsSetHostContextRequest;

$apps = $session->rpc()->mcp()->apps();

$tools = $apps->listTools(new MCPAppsListToolsRequest(
    serverName: 'my-server',
    originServerName: 'my-server',
));
$result = $apps->callTool(new McpAppsCallToolRequest(
    serverName: 'my-server',
    toolName: 'lookup',
    originServerName: 'my-server',
    arguments: ['query' => 'hello'],
));
$resource = $apps->readResource(new McpAppsReadResourceRequest(
    serverName: 'my-server',
    uri: 'ui://my-app/index.html',
));
$context = $apps->getHostContext();
$apps->setHostContext(new McpAppsSetHostContextRequest(
    context: new McpAppsSetHostContextDetails(theme: 'dark', locale: 'ja-JP'),
));
$diagnostics = $apps->diagnose(new MCPAppsDiagnoseRequest(serverName: 'my-server'));

// model
$session->rpc()->model()->getCurrent();
// Het weergavebeleid voor reasoning summaries van het huidige model ophalen (experimental)
$policy = $session->rpc()->model()->getReasoningSummaries(new ModelGetReasoningSummariesRequest(
    persistedShowReasoning: true, // weglaten als niet ingesteld
    summariesVisible: true, // of ze momenteel in de host-UI worden getoond
));
// $policy->ready, $policy->sessionShowsSummaries, $policy->visibility enz.
// Alleen de reasoning effort wijzigen zonder het geselecteerde model te veranderen (experimental)
$effort = $session->rpc()->model()->setReasoningEffort(
    new ModelSetReasoningEffortRequest(reasoningEffort: ReasoningEffort::HIGH),
);
// $effort->reasoningEffort
$session->rpc()->model()->switchTo(new ModelSwitchToRequest(modelId: 'gpt-4'));
// Met reasoningEffort (alleen ondersteunde modellen)
$session->rpc()->model()->switchTo(new ModelSwitchToRequest(modelId: 'claude-opus-4.7', reasoningEffort: ReasoningEffort::HIGH));
// Met reasoningSummary
$session->rpc()->model()->switchTo(new ModelSwitchToRequest(modelId: 'claude-opus-4.7', reasoningSummary: 'concise'));
// Met contextTier (alleen ondersteunde modellen)
$session->rpc()->model()->switchTo(new ModelSwitchToRequest(modelId: 'gpt-4o', contextTier: 'long_context'));
// modelCapabilities overschrijven
$session->rpc()->model()->switchTo(new ModelSwitchToRequest(
    modelId: 'gpt-4',
    modelCapabilities: new ModelCapabilitiesOverride(
        supports: new ModelCapabilitiesOverrideSupports(vision: true),
    ),
));
// Lijst met modellen die in de sessie beschikbaar zijn ophalen (experimental)
$models = $session->rpc()->model()->list();
$models->auto?->tiers; // Auto routing preferences die voor het account beschikbaar zijn
$session->rpc()->model()->list(new ModelListRequest(skipCache: true)); // cache overslaan

// De Auto routing preference wijzigen (het selected model blijft gelijk, experimental)
$session->rpc()->model()->switchAutoTier(new ModelSwitchAutoTierRequest(autoTier: AutoTier::BALANCE));
$session->rpc()->model()->switchAutoTier(new ModelSwitchAutoTierRequest(autoTier: null)); // terug naar provider-default Auto routing

// Aan de hostkant een lijst met toegestane modellen voor de sessie instellen of opheffen (experimental)
$session->rpc()->model()->setAllowedModels(new ModelSetAllowedModelsRequest(allowedModels: ['gpt-5']));
$session->rpc()->model()->setAllowedModels(new ModelSetAllowedModelsRequest(allowedModels: null)); // beperking opheffen

// Ook met de helper setModel() kun je reasoningEffort en modelCapabilities opgeven
$session->setModel('claude-opus-4.7', ReasoningEffort::HIGH);
$session->setModel('claude-opus-4.7', 'high'); // kan ook als string
$session->setModel('gpt-4', modelCapabilities: ['supports' => ['vision' => true]]); // kan ook als array
// Met autoTier (alleen geldig als modelId 'auto' is)
$session->setModel('auto', autoTier: AutoTier::INTELLIGENCE);

// Met de helper setAutoTier() alleen de Auto routing preference wijzigen zonder het model te veranderen (experimental)
$session->setAutoTier(AutoTier::EFFICIENCY);

// mode
$session->rpc()->mode()->get();
$modeResult = $session->rpc()->mode()->set(new ModeSetRequest(mode: 'plan'));
// $modeResult->modeApplied, $modeResult->modelChanged, $modeResult->confirmation enz.

// name
$session->rpc()->name()->get();
$session->rpc()->name()->set(new NameSetRequest(name: 'My Session'));
// Als de gebruiker geen naam heeft ingesteld, de samenvatting als sessienaam toepassen (experimental)
$autoName = $session->rpc()->name()->setAuto(new NameSetAutoRequest(summary: 'Summary of the session'));
// $autoName->applied

// plan
$session->rpc()->plan()->read();
$session->rpc()->plan()->update(new PlanUpdateRequest(content: '...'));
$session->rpc()->plan()->delete();
// De SQLite-todolijst lezen (planmodus)
$result = $session->rpc()->plan()->readSqlTodos();
// $result->rows - array van PlanSqlTodosRow (id, title, description, status)

// De SQLite-todolijst met afhankelijkheden lezen (experimental)
$result = $session->rpc()->plan()->readSqlTodosWithDependencies();
// $result->rows - array van PlanSqlTodosRow
// $result->dependencies - array van PlanSqlTodoDependency (todo_id, depends_on)

// 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: '...'));
$session->rpc()->workspaces()->statFile(new WorkspacesStatFileRequest(path: 'file.txt'));
$session->rpc()->workspaces()->createDirectory(new WorkspacesCreateDirectoryRequest(path: 'new/dir', recursive: true));
$session->rpc()->workspaces()->removePath(new WorkspacesRemovePathRequest(path: 'old/dir', recursive: true, force: true));
$session->rpc()->workspaces()->renamePath(new WorkspacesRenamePathRequest(source: 'old.txt', destination: 'new.txt'));

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

// De LSP-configuratie expliciet herladen (experimental)
$session->rpc()->lsp()->initialize([
    'workingDirectory' => base_path(),
    'gitRoot' => base_path(),
    'force' => true,
]);

// instructions discover (instructiebestanden detecteren)
use Revolution\Copilot\Types\Rpc\InstructionsDiscoverRequest;

$result = $session->rpc()->instructions()->discover();
// $result->sources - array van InstructionSource
$result = $session->rpc()->instructions()->discover(new InstructionsDiscoverRequest(
    projectPaths: ['/path/to/project'],
    excludeHostInstructions: true, // instructies op hostniveau uitsluiten
));

// fleet
$session->rpc()->fleet()->start(new FleetStartRequest(prompt: '...'));
// Zie fleet-mode.md 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 (experimental: skillbeheer)
$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();
$session->rpc()->skills()->ensureLoaded(); // nog niet geladen skills laden (geen herladen)
$invoked = $session->rpc()->skills()->getInvoked();
// $invoked->skills - geschiedenis van skills die tijdens de sessie zijn aangeroepen

// mcp (experimental: beheer van MCP-servers)
$servers = $session->rpc()->mcp()->list();
// Geconfigureerde URL van een HTTP/SSE-server: $servers->servers[0]->url
$session->rpc()->mcp()->enable(new McpEnableRequest(serverName: 'server-name'));
$session->rpc()->mcp()->disable(new McpDisableRequest(serverName: 'server-name'));
$session->rpc()->mcp()->reload();
// Het lopende laden van MCP naar de achtergrond verplaatsen (wachtende beurten vrijgeven)
$session->rpc()->mcp()->moveLoadingToBackground();

// Een MCP-server binnen de sessie starten of herstarten (de persistente configuratie verandert niet)
use Revolution\Copilot\Types\Rpc\McpRestartServerRequest;
use Revolution\Copilot\Types\Rpc\McpStartServerRequest;

$session->rpc()->mcp()->startServer(new McpStartServerRequest(
    serverName: 'server-name',
    config: ['type' => 'http', 'url' => 'https://mcp.example.com'],
));
$session->rpc()->mcp()->restartServer(new McpRestartServerRequest(
    serverName: 'server-name',
    expectedInstallationId: 'installation-id',
));

// De automatisch beheerde GitHub MCP-server verwijderen en de manier van oplossen van omgevingsvariabelen instellen
$removed = $session->rpc()->mcp()->removeGitHub();
$mode = $session->rpc()->mcp()->setEnvValueMode(['mode' => 'indirect']);
// $removed->removed, $mode->mode

// MCP-sampling uitvoeren en annuleren
use Revolution\Copilot\Types\Rpc\McpCancelSamplingExecutionParams;
use Revolution\Copilot\Types\Rpc\McpExecuteSamplingParams;

$sampling = $session->rpc()->mcp()->executeSampling(new McpExecuteSamplingParams(
    requestId: 'sampling-1',
    serverName: 'server-name',
    mcpRequestId: 'mcp-request-1',
    request: ['messages' => [], 'maxTokens' => 256],
));
$cancelled = $session->rpc()->mcp()->cancelSamplingExecution(
    new McpCancelSamplingExecutionParams(requestId: 'sampling-1'),
);

// Controleren of een MCP-server draait
use Revolution\Copilot\Types\Rpc\McpIsServerRunningRequest;

$result = $session->rpc()->mcp()->isServerRunning(new McpIsServerRunningRequest(serverName: 'my-server'));
// $result->running - of de server draait

// De toollijst van een MCP-server ophalen
use Revolution\Copilot\Types\Rpc\McpListToolsRequest;

$result = $session->rpc()->mcp()->listTools(new McpListToolsRequest(serverName: 'my-server'));
// $result->tools - array van McpTools (name, description)

// MCP-prompts weergeven en ophalen (experimental)
use Revolution\Copilot\Types\Rpc\McpPromptsGetRequest;
use Revolution\Copilot\Types\Rpc\McpPromptsListRequest;

$prompts = $session->rpc()->mcp()->listPrompts(new McpPromptsListRequest(serverName: 'my-server'));
$rendered = $session->rpc()->mcp()->getPrompt(new McpPromptsGetRequest(
    serverName: 'my-server',
    promptName: 'summarize',
    arguments: ['document' => 'README.md'],
));
// $prompts->prompts - MCP-promptdefinities
// $rendered->messages - gerenderde prompt (wordt niet naar het model verzonden)

// Een MCP-server stoppen
use Revolution\Copilot\Types\Rpc\McpStopServerRequest;

$session->rpc()->mcp()->stopServer(new McpStopServerRequest(serverName: 'my-server'));

// De lijst met MCP-resources ophalen (experimental)
use Revolution\Copilot\Types\Rpc\McpResourcesListRequest;

$result = $session->rpc()->mcp()->resources()->list(new McpResourcesListRequest(serverName: 'my-server'));
// $result->resources - array van McpResource (uri, name, title, mimeType enz.)
// $result->nextCursor - cursor voor de volgende pagina (indien aanwezig)

// Een MCP-resource ophalen (experimental)
use Revolution\Copilot\Types\Rpc\McpResourcesReadRequest;

$result = $session->rpc()->mcp()->resources()->read(new McpResourcesReadRequest(serverName: 'my-server', uri: 'ui://example'));
// $result->contents - array van McpResourceContent

// De lijst met MCP-resourcetemplates ophalen (experimental)
use Revolution\Copilot\Types\Rpc\McpResourcesListTemplatesRequest;

$result = $session->rpc()->mcp()->resources()->listTemplates(new McpResourcesListTemplatesRequest(serverName: 'my-server'));
// MCP OAuth-login (voor MCP-servers die authenticatie vereisen)
use Revolution\Copilot\Types\Rpc\McpOauthCompleteRequest;
use Revolution\Copilot\Types\Rpc\McpOauthLoginRequest;
use Revolution\Copilot\Types\Rpc\McpOauthProbeRequest;
use Revolution\Copilot\Types\Rpc\SessionMcpOauthCancelLoginRequest;
use Revolution\Copilot\Types\Rpc\SessionMcpOauthPrepareLoginRequest;

$result = $session->rpc()->mcp()->login(new McpOauthLoginRequest(serverName: 'my-server'));
// $result->authorizationUrl - URL van de OAuth-flow (als authenticatie nodig is)
// Bij een door de host beheerde OAuth-redirectflow geef je redirectUri op en roep je na de callback complete() aan
$result = $session->rpc()->mcp()->login(new McpOauthLoginRequest(
    serverName: 'my-server',
    redirectUri: 'http://localhost:3000/oauth/callback',
));
$session->rpc()->mcp()->complete(new McpOauthCompleteRequest(
    authorizationId: $result->authorizationId,
    callbackUrl: $callbackUrl,
));

// De OAuth-status controleren en een login gekoppeld aan een installatie in eigendom voorbereiden of annuleren
$probe = $session->rpc()->mcp()->oauth()->probe(new McpOauthProbeRequest(serverName: 'my-server'));
$prepared = $session->rpc()->mcp()->oauth()->prepareLogin(new SessionMcpOauthPrepareLoginRequest(
    serverName: 'my-server',
    expectedInstallationId: 'installation-id',
));
$cancelled = $session->rpc()->mcp()->oauth()->cancelLogin(new SessionMcpOauthCancelLoginRequest(
    expectedInstallationId: 'installation-id',
    loginId: $prepared->loginId,
));

// plugins (experimental: lijst met plugins)
$session->rpc()->plugins()->list();
// Plugins herladen
$session->rpc()->plugins()->reload();
// Herladen met opties
use Revolution\Copilot\Types\Rpc\PluginsReloadRequest;

$session->rpc()->plugins()->reload(new PluginsReloadRequest(
    reloadMcp: true,      // MCP-serverconfiguratie herladen
    reloadHooks: true,    // hooks herladen
    reloadCustomAgents: false, // aangepaste agents niet herladen
));

// extensions (experimental: beheer van extensies)
$policy = $session->rpc()->extensions()->getPolicy(); // ExtensionManagedPolicy
// $policy->standalone is allowed / plugin_only / pending
// Het beleid is een momentopname, geen token voor startautorisatie. Gebruik het niet voor daadwerkelijke startbeslissingen
$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()->reconcile(); // host-only: synchroniseert de effectieve membership opnieuw en geeft de settled list terug
$session->rpc()->extensions()->reload();

// managedSettings (experimental: beheerde instellingen van de sessie)
// Evalueert de Policy Helper opnieuw en geeft de resulterende effectieve instellingen terug
$settings = $session->rpc()->managedSettings()->recheckPolicyHelper(); // ManagedSettingsResolvedData

// compaction → hernoemd naar history
$session->rpc()->history()->compact();
// Handmatige compressie afbreken / compressie op de achtergrond annuleren
$session->rpc()->history()->abortManualCompaction();
$session->rpc()->history()->cancelBackgroundCompaction();
// Een samenvatting ophalen voor overdracht naar een andere sessie
$summary = $session->rpc()->history()->summarizeForHandoff()->summary;
// De geschiedenis vanaf een bepaald event inkorten
$session->rpc()->history()->truncate(new HistoryTruncateRequest(
    eventId: 'evt-123', // dit event en alle latere events worden verwijderd
));

// tools (protocol v3+: reageren op external_tool.requested-events)
// De runtime-toolset vóór het verzenden initialiseren en valideren (experimental, gebruikt voor onder meer subagentsessies)
$session->rpc()->tools()->initializeAndValidate();
// Retourneert een leeg ToolsInitializeAndValidateResult

// Een tool die momenteel aan de sessie is blootgesteld uitvoeren via de native aanroeppipeline (experimental)
use Revolution\Copilot\Types\Rpc\ToolsExecuteRequest;

$result = $session->rpc()->tools()->execute(new ToolsExecuteRequest(
    name: 'search',
    arguments: ['query' => 'Laravel'],
    toolCallId: 'call-123', // optioneel. Gebruikt voor correlatie met de aanroep
));

if (is_string($result)) {
    // Eenvoudig tekstresultaat
    echo $result;
} else {
    // ToolResultExpanded: textResultForLlm, resultType, newMessages,
    // mcpMeta, structuredContent, taskCompletionDecision enz.
    echo $result->textResultForLlm;
    // resultType is een ToolResultType of een string die een onbekende waarde bevat
}

// Kan ook als array. toolCallId mag worden weggelaten, en sessionId wordt overschreven met de waarde van deze sessie
$session->rpc()->tools()->execute([
    'name' => 'search',
    'arguments' => ['query' => 'Copilot'],
]);
// arguments: [] wordt verzonden als JSON-object {}, en scalar/null/niet-lege arrays behouden hun JSON-waarde

// execute() doorloopt de normale native aanroeppipeline van tools en omzeilt dus geen permissiecontroles.
// Als een tool goedkeuring vereist, wordt dat zoals gewoonlijk afgehandeld door de onPermissionRequest-handler in SessionConfig.
$session->rpc()->tools()->handlePendingToolCall(new HandlePendingToolCallRequest(
    requestId: '...',
    result: 'Resultaat van de tooluitvoering',
));
// De huidige toolmetadata van de sessie ophalen (experimental)
$session->rpc()->tools()->getCurrentMetadata();
// De externe tools die deze verbinding levert volledig vervangen (experimental)
$session->rpc()->tools()->set(['tools' => [
    ['name' => 'search', 'description' => 'Search documents', 'parameters' => ['type' => 'object']],
]]);
// De subagentinstellingen ophalen die op de huidige sessie zijn toegepast (experimental)
$settings = $session->rpc()->tools()->getSubagentSettings();
// $settings->subagents is SubagentSettings, of null als er geen instellingenblok is
// De instellingen van subagents bijwerken (experimental)
use Revolution\Copilot\Enums\SubagentSettingsEntryContextTier;
use Revolution\Copilot\Types\Rpc\SubagentSettings;
use Revolution\Copilot\Types\Rpc\SubagentSettingsEntry;
use Revolution\Copilot\Types\Rpc\UpdateSubagentSettingsRequest;

$result = $session->rpc()->tools()->updateSubagentSettings(new UpdateSubagentSettingsRequest(
    subagents: new SubagentSettings(agents: [
        'my-agent' => new SubagentSettingsEntry(
            contextTier: SubagentSettingsEntryContextTier::Default,
            model: 'gpt-5',
        ),
    ]),
));
// Het toepassen van de instellingen retourneert een leeg ToolsUpdateSubagentSettingsResult

// permissions (protocol v3+: reageren op permission.requested-events)
use Revolution\Copilot\Types\Rpc\FolderTrustAddParams;
use Revolution\Copilot\Types\Rpc\PermissionLocationAddToolApprovalParams;
use Revolution\Copilot\Types\Rpc\PermissionLocationApplyParams;
use Revolution\Copilot\Types\Rpc\PermissionLocationResolveParams;
use Revolution\Copilot\Types\Rpc\PermissionsLocationsAddToolApprovalDetailsCommands;

$session->rpc()->permissions()->handlePendingPermissionRequest(new PermissionDecisionRequest(
    requestId: '...',
    result: PermissionDecision::approveOnce(),
));
// Alle permissieverzoeken binnen de sessie automatisch goedkeuren
$session->rpc()->permissions()->setApproveAll(new PermissionsSetApproveAllRequest(enabled: true));
// De permissiemodus instellen (manual / assisted / allow-all)
$session->rpc()->permissions()->setMode(new PermissionsSetModeRequest(mode: PermissionMode::AllowAll));
// De huidige permissiemodus ophalen
$mode = $session->rpc()->permissions()->getMode();
// Permissiegoedkeuringen met sessiescope resetten
$session->rpc()->permissions()->resetSessionApprovals();
// De lijst met momenteel openstaande permissieverzoeken ophalen
$pending = $session->rpc()->permissions()->pendingRequests();
// De eventbrug voor permissieverzoeken in-/uitschakelen
$session->rpc()->permissions()->setRequired(new PermissionsSetRequiredRequest(required: true));
// Permissieregels toevoegen/verwijderen
$session->rpc()->permissions()->modifyRules(new PermissionsModifyRulesParams(
    scope: PermissionsModifyRulesScope::SESSION,
    add: [['tool' => 'bash', 'decision' => 'allow']],
));
// Melden dat een permissieprompt is getoond
$session->rpc()->permissions()->notifyPromptShown(new PermissionPromptShownNotification(message: 'tool permission prompt'));
// Padpermissies
$paths = $session->rpc()->permissions()->paths()->list();
$session->rpc()->permissions()->paths()->add(new PermissionPathsAddParams(path: '/path/to/allow'));
$session->rpc()->permissions()->paths()->updatePrimary(new PermissionPathsUpdatePrimaryParams(path: '/path/to/allow'));
$session->rpc()->permissions()->paths()->isPathWithinAllowedDirectories(new PermissionPathsAllowedCheckParams(path: '/path/to/allow/file.txt'));
$session->rpc()->permissions()->paths()->isPathWithinWorkspace(new PermissionPathsWorkspaceCheckParams(path: '/path/to/allow/file.txt'));
// URL-permissies
$session->rpc()->permissions()->urls()->setUnrestrictedMode(
    new PermissionUrlsSetUnrestrictedModeParams(enabled: true)
);
// De permissielocatie van de werkdirectory oplossen en opgeslagen regels toepassen
$location = $session->rpc()->permissions()->locations()->resolve(
    new PermissionLocationResolveParams(workingDirectory: '/path/to/repo')
);
$session->rpc()->permissions()->locations()->apply(
    new PermissionLocationApplyParams(workingDirectory: '/path/to/repo')
);
// Een toolgoedkeuring persistent opslaan in de permissielocatie
$session->rpc()->permissions()->locations()->addToolApproval(
    new PermissionLocationAddToolApprovalParams(
        approval: new PermissionsLocationsAddToolApprovalDetailsCommands(commandIdentifiers: ['bash']),
        locationKey: $location->locationKey,
    )
);
// De vertrouwensstatus van een map controleren en toevoegen
$trusted = $session->rpc()->permissions()->folderTrust()->isTrusted(['path' => '/path/to/repo']);
$session->rpc()->permissions()->folderTrust()->addTrusted(new FolderTrustAddParams(path: '/path/to/repo'));

// commands: de lijst met slash-commando's ophalen die in de sessie beschikbaar zijn
use Revolution\Copilot\Types\Rpc\CommandsListRequest;

$list = $session->rpc()->commands()->list();
// $list->commands - array van SlashCommandInfo
// $list->commands[0]->name - commandonaam (zonder slash)
// $list->commands[0]->description - beschrijving van het commando
// $list->commands[0]->kind - commandocategorie (builtin, skill, client)
// $list->commands[0]->allowDuringAgentExecution - of het tijdens de uitvoering van een agent bruikbaar is

// Lijst ophalen met een filter
$list = $session->rpc()->commands()->list(new CommandsListRequest(
    includeBuiltins: true,
    includeSkills: false,
));

// commands: een slash-commando aanroepen
use Revolution\Copilot\Types\Rpc\CommandsInvokeRequest;

$result = $session->rpc()->commands()->invoke(new CommandsInvokeRequest(
    name: 'help',
    input: 'optional input text',
));

// commands: reageren op een commando-aanroepevent
$session->rpc()->commands()->handlePendingCommand(new CommandsHandlePendingCommandRequest(
    requestId: '...',
));

// commands: een slash-commando synchroon uitvoeren
use Revolution\Copilot\Types\Rpc\ExecuteCommandParams;

$result = $session->rpc()->commands()->execute(new ExecuteCommandParams(
    commandName: 'review',
    args: 'src/',
), timeout: 120.0); // wachttijd op het CLI-antwoord (seconden). Standaard 30 seconden
// $result->error - foutmelding als de uitvoering mislukt (null bij succes)

// commands: reageren op een commando in de wachtrij
$session->rpc()->commands()->respondToQueuedCommand(new CommandsRespondToQueuedCommandRequest(
    requestId: '...',
    result: new QueuedCommandResult(handled: true),
));

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

// ui: een tijdelijke vraag die niet aan de gespreksgeschiedenis wordt toegevoegd
$result = $session->rpc()->ui()->ephemeralQuery(new UIEphemeralQueryRequest(
    question: 'Wat zijn de belangrijkste punten van het gesprek tot nu toe?',
));
// $result->answer

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

// ui: reageren op openstaande verzoeken via broadcast-events
use Revolution\Copilot\Enums\UIAutoModeSwitchResponse;
use Revolution\Copilot\Types\Rpc\UIExitPlanModeResponse;
use Revolution\Copilot\Types\Rpc\UIHandlePendingAutoModeSwitchRequest;
use Revolution\Copilot\Types\Rpc\UIHandlePendingExitPlanModeRequest;
use Revolution\Copilot\Types\Rpc\UIHandlePendingSamplingRequest;
use Revolution\Copilot\Types\Rpc\UIHandlePendingUserInputRequest;
use Revolution\Copilot\Types\Rpc\UIUserInputResponse;

$result = $session->rpc()->ui()->handlePendingUserInput(new UIHandlePendingUserInputRequest(
    requestId: '...',
    response: new UIUserInputResponse(answer: 'blue', wasFreeform: false),
));

$result = $session->rpc()->ui()->handlePendingExitPlanMode(new UIHandlePendingExitPlanModeRequest(
    requestId: '...',
    response: new UIExitPlanModeResponse(approved: true, selectedAction: 'autopilot_fleet'),
));

$result = $session->rpc()->ui()->handlePendingAutoModeSwitch(new UIHandlePendingAutoModeSwitchRequest(
    requestId: '...',
    response: UIAutoModeSwitchResponse::Yes,
));

$result = $session->rpc()->ui()->handlePendingSampling(new UIHandlePendingSamplingRequest(
    requestId: '...',
    response: ['result' => '...'],
));
// Elke methode retourneert UIHandlePendingResult. Met $result->success controleer je of het antwoord is geaccepteerd.

// onExitPlanModeRequest / onAutoModeSwitchRequest in SessionConfig antwoorden automatisch via reverse-RPC.
// Als je hetzelfde verzoek handmatig via events beantwoordt, gebruik dan niet beide routes tegelijk.

// log: berichten vastleggen in de tijdlijn van de sessie
$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 sessie
$result = $session->rpc()->shell()->exec(new ShellExecRequest(command: 'ls -la'));
// Haal met $result->processId het proces-ID op om te killen of de uitvoer te volgen

$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
));

// Een door de gebruiker aangevraagd shellcommando annuleren
use Revolution\Copilot\Types\Rpc\ShellExecuteUserRequestedRequest;
use Revolution\Copilot\Types\Rpc\ShellCancelUserRequestedRequest;

$execution = $session->rpc()->shell()->executeUserRequested(new ShellExecuteUserRequestedRequest(
    requestId: 'req-123',
    command: 'pwd',
), timeout: 120.0); // wachttijd op het CLI-antwoord (seconden). Standaard 30 seconden
// $execution->toolCallId / success / output / exitCode / error
// Om tijdens de uitvoering vanuit een ander proces te annuleren, geef je dezelfde requestId op

$cancelled = $session->rpc()->shell()->cancelUserRequested(
    new ShellCancelUserRequestedRequest(requestId: 'req-123')
);
// $cancelled->cancelled - of het annuleren is gelukt

// telemetry (experimental: sessietelemetrie)
use Revolution\Copilot\Types\Rpc\TelemetrySetFeatureOverridesRequest;

$telemetry = $session->rpc()->telemetry();
$engagement = $telemetry->getEngagementId();
// $engagement->engagementId - de engagement-ID indien beschikbaar, anders null

$telemetry->setFeatureOverrides(new TelemetrySetFeatureOverridesRequest(
    features: ['feature-key' => 'override-value'],
));
// De overrides worden aan latere telemetrie-events gekoppeld en vervangen eerdere overrides.
// Dit staat los van SessionConfig::$enableSessionTelemetry (waarmee interne telemetrie wordt ingeschakeld).

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

// auth: de authenticatiestatus van de sessie 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-abonnement (individual, business enz.)
// $status->statusMessage - bericht over de authenticatiestatus

// provider: endpointinformatie ophalen van de provider die de sessie gebruikt (experimental)
// Gebruikt bij het rechtstreeks aanroepen van een LLM-backend in een BYOK-configuratie (Bring Your Own Key)
use Revolution\Copilot\Types\Rpc\ProviderGetEndpointRequest;

$endpoint = $session->rpc()->provider()->getEndpoint();
// $endpoint->baseUrl - basis-URL om door te geven aan een LLM-clientbibliotheek
// $endpoint->type - providertype (openai, anthropic enz.)
// $endpoint->headers - HTTP-headers die in verzoeken moeten worden meegestuurd
// $endpoint->apiKey - authenticatiegegevens (nullable)
// $endpoint->sessionToken - kortlevende sessiecredentials (nullable)
// $endpoint->wireApi - providerspecifieke wire-API (nullable)

// Het endpoint voor een specifiek model ophalen
$endpoint = $session->rpc()->provider()->getEndpoint(
    new ProviderGetEndpointRequest(model: 'gpt-5')
);

// provider: door de host beheerde modellen uit het BYOK-register terugtrekken (experimental)
$result = $session->rpc()->provider()->withdraw(['models' => ['provider/model']]);
// $result->withdrawn, $result->providersRemoved, $result->modelDeselected

// queue: items voor de gebruiker in de wachtrij bekijken en beheren
$pending = $session->rpc()->queue()->pendingItems();
// $pending->items - array van QueuePendingItems
// $pending->items[0]->kind - QueuePendingItemsKind (Command / Message)

$removed = $session->rpc()->queue()->removeMostRecent();
// $removed->removed - of het meest recente item kon worden verwijderd

$session->rpc()->queue()->clear();

// Een item op een bepaalde positie invoegen (position begint bij 0)
use Revolution\Copilot\Types\Rpc\QueueInsertAtRequest;
use Revolution\Copilot\Types\Rpc\QueueInsertMessage;

$queue = $session->rpc()->queue();
$inserted = $queue->insertAt(new QueueInsertAtRequest(
    position: 0,
    message: new QueueInsertMessage(prompt: 'Review the changes'),
));
// $inserted->id - ID van het ingevoegde item

$queue->moveItem(['id' => $inserted->id, 'toPosition' => 1]);
$duplicated = $queue->duplicateAt(['id' => $inserted->id]);
$queue->updateText(['id' => $duplicated->id, 'prompt' => 'Review and test the changes']);
$removedAt = $queue->removeAt(['id' => $duplicated->id]);
// $removedAt->removed - of het item kon worden verwijderd

$sent = $queue->sendNow(['id' => $inserted->id]);
// $sent->steered - of het naar de lopende beurt is gestuurd

// Het leegmaken van de wachtrij pauzeren. De pauze wordt niet automatisch opgeheven, dus hervat altijd met false
$queue->setDrainPaused(['paused' => true]);
$queue->setDrainPaused(['paused' => false]);

// schedule (experimental: beheer van geplande prompts)
$schedule = $session->rpc()->schedule()->list();
// $schedule->entries - array van ScheduleEntry

use Revolution\Copilot\Types\Rpc\ScheduleStopRequest;

$stopped = $session->rpc()->schedule()->stop(new ScheduleStopRequest(id: 1));
// $stopped->stopped - of het stoppen is gelukt

// tasks (experimental: beheer van achtergrondtaken)
// Een agenttaak starten en de ID ophalen
use Revolution\Copilot\Types\Rpc\TasksStartAgentRequest;

$result = $session->rpc()->tasks()->startAgent(new TasksStartAgentRequest(
    agentType: 'explore',
    prompt: 'Search for all TODO comments in the codebase',
    name: 'todo-search',
    description: 'Find TODO items', // optioneel
    model: 'gpt-4o', // optioneel
));
// $result->agentId - ID van de achtergrondtaak

// De huidige takenlijst ophalen
$list = $session->rpc()->tasks()->list();
// $list->tasks - array van TaskAgentInfo, TaskShellInfo en TaskClientInfo

// De uitvoer van een losgekoppelde shell incrementeel lezen met een cursor
use Revolution\Copilot\Types\Rpc\TasksReadOutputRequest;

$cursor = null;
do {
    $output = $session->rpc()->tasks()->readOutput(new TasksReadOutputRequest(
        id: 'shell-1',
        cursor: $cursor,
        waitMs: 1000,
    ));
    echo $output->text;
    $cursor = $output->cursor;
} while ($output->exit === null);
// $output->exit->status - eindstatus van de taak
// $output->exit->exitCode - exitcode van het proces (nullable)

// Eén leesactie is maximaal 64 KiB. waitMs is standaard 0, maximaal 30000 ms.
// stdout en stderr worden samengevoegd. Als de cursor ongeldig wordt, lees dan opnieuw zonder cursor.

// Een job in eigendom van de applicatie als taak registreren
use Revolution\Copilot\Types\Rpc\TasksRegisterRequest;

$registered = $session->rpc()->tasks()->register(new TasksRegisterRequest(
    clientTaskId: 'import-123',
    description: 'Klantgegevens importeren',
    cancellable: true,
    displayName: 'Klantimport', // optioneel
));
// $registered->task->id - door de CLI toegewezen taak-ID
// $registered->created / $registered->reclaimed - status van nieuw aangemaakt / opnieuw opgeëiste verweesde taak

// De voortgang van een taak in eigendom van de client bijwerken
use Revolution\Copilot\Enums\TaskClientActiveStatus;
use Revolution\Copilot\Enums\TaskClientUpdateKind;
use Revolution\Copilot\Types\Rpc\TaskClientUpdate;
use Revolution\Copilot\Types\Rpc\TasksUpdateRequest;

$updated = $session->rpc()->tasks()->update(new TasksUpdateRequest(
    id: $registered->task->id,
    sequence: 1,
    update: new TaskClientUpdate(
        kind: TaskClientUpdateKind::Progress,
        status: TaskClientActiveStatus::Running,
        phase: 'importing',
        percentage: 25,
    ),
));
// Verhoog sequence bij elke update

// Voltooiing melden
$completed = $session->rpc()->tasks()->update(new TasksUpdateRequest(
    id: $registered->task->id,
    sequence: 2,
    update: new TaskClientUpdate(
        kind: TaskClientUpdateKind::Completed,
        result: ['imported' => 100],
    ),
));

// De voortgang van een taak ophalen (null als die niet wordt gevolgd)
$progress = $session->rpc()->tasks()->getProgress(['id' => $registered->task->id])->progress;
// TaskAgentProgress, TaskClientProgress, TaskShellProgress of null

// De status van losgekoppelde shells bijwerken en wachten tot achtergrondwerk klaar is
$session->rpc()->tasks()->refresh();
$session->rpc()->tasks()->waitForPending();

// De taak ophalen die momenteel naar de achtergrond kan, of die taak direct naar de achtergrond verplaatsen
$promotable = $session->rpc()->tasks()->getCurrentPromotable()->task;
$promotedCurrent = $session->rpc()->tasks()->promoteCurrentToBackground()->task;

// Een taak naar de achtergrondmodus verplaatsen (synchroon wachten opheffen)
use Revolution\Copilot\Types\Rpc\TasksPromoteToBackgroundRequest;

$promoted = $session->rpc()->tasks()->promoteToBackground(
    new TasksPromoteToBackgroundRequest(id: $result->agentId)
);
// $promoted->promoted - of het verplaatsen is gelukt

// Een taak annuleren
use Revolution\Copilot\Types\Rpc\TasksCancelRequest;

$cancelled = $session->rpc()->tasks()->cancel(
    new TasksCancelRequest(id: $result->agentId)
);
// $cancelled->cancelled - of het annuleren is gelukt

// Een voltooide of geannuleerde taak verwijderen
use Revolution\Copilot\Types\Rpc\TasksRemoveRequest;

$removed = $session->rpc()->tasks()->remove(
    new TasksRemoveRequest(id: $result->agentId)
);
// $removed->removed - of het verwijderen is gelukt

// Een bericht sturen naar een draaiende agenttaak (sturing)
use Revolution\Copilot\Types\Rpc\TasksSendMessageRequest;

$sent = $session->rpc()->tasks()->sendMessage(
    new TasksSendMessageRequest(id: $result->agentId, message: 'Doorzoek ook een andere map')
);
// $sent->sent - of het bericht succesvol is verzonden
// $sent->error - foutmelding als het verzenden mislukt (nullable)

// Alleen de hoofdbeurt onderbreken en de prompts in de wachtrij bewaren voor de volgende beurt
use Revolution\Copilot\Types\Rpc\InterruptMainTurnRequest;

$interrupted = $session->rpc()->interruptMainTurn(
    new InterruptMainTurnRequest(flushQueued: true)
);
// $interrupted->interrupted - of de lopende hoofdbeurt kon worden onderbroken

// Alle draaiende achtergrondagents annuleren zonder de hoofdbeurt te onderbreken
$cancelledCount = $session->rpc()->cancelAllBackgroundAgents();
// Aantal geannuleerde agents