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

# Skills, Plugins, Agents, Instructions und Extensions

> Mit ServerRpc des Laravel Copilot SDK verwalten Sie Skills, Plugins, Agents, Instructions, Extensions und LSP-Einstellungen.

## Skills, Plugins, Agents, Instructions und Extensions

Geltungsbereich: ServerRpc (serverweite Operationen, die an den Client gebunden sind)

Eine Übersicht über RPC und die Liste aller RPC-Seiten finden Sie unter [RPC](https://kawax.biz/de/packages/laravel-copilot-sdk/rpc.md).

```php theme={null}
use Revolution\Copilot\Enums\CatalogCandidateKind;
use Revolution\Copilot\Enums\CatalogCapability;
use Revolution\Copilot\Enums\CatalogSelectionDecision;
use Revolution\Copilot\Enums\CatalogTrustTier;
use Revolution\Copilot\Enums\SkillInstallationManagementOutcomeKind;
use Revolution\Copilot\Enums\SkillInstallationManagementResultKind;
use Revolution\Copilot\Enums\SkillsRemoveSourceOutcomeKind;
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\CatalogRecommendRequest;
use Revolution\Copilot\Types\Rpc\CatalogSearchRequest;
use Revolution\Copilot\Types\Rpc\CatalogSelectionRequest;
use Revolution\Copilot\Types\Rpc\InstructionsDiscoverRequest;
use Revolution\Copilot\Types\Rpc\InstructionsGetDiscoveryPathsRequest;
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\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\SkillPlanUninstallRequest;
use Revolution\Copilot\Types\Rpc\SkillSetEnabledRequest;
use Revolution\Copilot\Types\Rpc\SkillsInstallSourceRequest;
use Revolution\Copilot\Types\Rpc\SkillsRemoveSourceRequest;
use Revolution\Copilot\Types\Rpc\SkillsGetDiscoveryPathsRequest;

// skills (Skill-Verwaltung auf Serverebene)
// Skills erkennen
$result = Copilot::client()->rpc()->skills()->discover();
// $result->skills ist ein Array von ServerSkill
// Optional Projektpfade angeben
$result = Copilot::client()->rpc()->skills()->discover(new SkillsDiscoverRequest(
    projectPaths: ['/path/to/project'],
    skillDirectories: ['/custom/skills'],
));

// Zu deaktivierende Skills festlegen
Copilot::client()->rpc()->skills()->config()->setDisabledSkills(
    new SkillsConfigSetDisabledSkillsRequest(disabledSkills: ['skill-name'])
);

// Einzelne Skills aktivieren/deaktivieren
Copilot::client()->rpc()->skills()->config()->setSkillDisabled(
    new SkillsConfigSetSkillDisabledRequest(name: 'skill-name', disabled: true)
);

// Skill-Kandidaten über catalog.search → catalog.select auswählen (experimental)
$skills = Copilot::client()->rpc()->skills();
$installed = $skills->installSource(new SkillsInstallSourceRequest(
    source: 'https://example.test/skills/review/SKILL.md',
    cwd: '/workspace',
    personalSkillsDir: '/home/user/.copilot/skills',
    projectSkillsDir: '/workspace/.copilot/skills',
    project: false,
    skillDirectories: ['/custom/skills'],
    userAgent: 'my-app/1.0',
));
// Die zurückgegebenen skillDirectories auf Aufruferseite dauerhaft speichern
$skillDirectories = $installed->skillDirectories;

// Ein Erkennungsverzeichnis abmelden. Der Inhalt des Verzeichnisses wird nicht gelöscht
$removed = $skills->removeSource(new SkillsRemoveSourceRequest(
    target: '/custom/skills',
    cwd: '/workspace',
    skillDirectories: $skillDirectories,
));
if ($removed->kind === SkillsRemoveSourceOutcomeKind::Removed) {
    $skillDirectories = $removed->result->skillDirectories;
}
// Erfordert das Löschen von Dateien ein Inventar und lassen Sie es weg, wird needs-inventory zurückgegeben und nichts geändert

// Einen Skill-Kandidaten mit catalog.search → catalog.select auswählen (experimental)

$contract = new CatalogClientContract(1, ['catalog-selection', 'ai-skill-installation']);
$catalog = Copilot::client()->rpc()->catalog();

// Offizielle Produktempfehlungen aus einem Produktnamen und einer vollständigen Aufgabe abrufen (experimental)
$recommendations = $catalog->recommend(new CatalogRecommendRequest(
    contract: new CatalogClientContract(1, [CatalogCapability::CatalogRecommend->value]),
    query: 'Review this repository and identify security issues.',
    product: 'GitHub Copilot',
));

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

// Für einen Kategoriefilter catalog-search-categories anfordern
$categoryContract = new CatalogClientContract(3, [
    CatalogCapability::CatalogSearchCategories->value,
]);
$categorySearch = $catalog->search(new CatalogSearchRequest(
    contract: $categoryContract,
    query: 'design tools',
    categories: ['design', 'test'],
));
// Bei Angabe von policySessionId fordern Sie im contract auch credential-required und session-bound an;
// die Bindung erfolgt nur an eine bestehende attached Session. Es wird keine Session neu erstellt oder fortgesetzt.

// Gespeicherte und generierte Catalog-Feeds (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],
));

// Für die Bindung an eine bestehende attached Session zusätzlich die session-bound-Capability anfordern
$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 behalten die Feed-Reihenfolge bei. Einträge, die nicht zum Trust-Tier passen, behalten als filtered ihre Position,
// und nicht anzeigbare Einträge werden als unavailable mit reason zurückgegeben.
// Existiert kein Feed, gilt kind=unavailable, reason=feed-not-found. Auch Authentifizierungs-, Aushandlungs- und Richtlinienablehnungen
// werden als jeweils typisierte Ergebnisse zurückgegeben; Catalog-Feed-RPCs führen keine Installationen oder Konfigurationen durch.

// Installationsplan für Skills erstellen und anwenden

$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() wird nach der Bestätigung über installations.confirm angewendet
        $result = $skills->applyInstall(new SkillApplyInstallRequest(
            contract: $contract,
            planHandle: $planned->outcome->plan['planHandle'],
            policySessionId: $sessionId,
        ));
    }
}

// Installierte Skills und laufende Operationen
$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,
));

// Auch die Deinstallation wird erst nach Prüfung des Plans angewendet
$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: Verzeichnisse abrufen, in denen Skills erstellt werden können (experimental)
// Liste der Verzeichnisse, in denen die Runtime abgelegte Skills erkennt

$result = Copilot::client()->rpc()->skills()->getDiscoveryPaths();
// $result->paths ist ein Array von SkillDiscoveryPath
// $result->paths[0]->path - Verzeichnispfad
// $result->paths[0]->scope - Geltungsbereich (user, project, plugin)
// $result->paths[0]->preferredForCreation - Ob es das empfohlene Verzeichnis für Neuanlagen ist
// Optional nach Scope filtern
$result = Copilot::client()->rpc()->skills()->getDiscoveryPaths(
    new SkillsGetDiscoveryPathsRequest(scope: 'project')
);

// plugins (Plugin-Verwaltung im Server-Scope)

$plugins = Copilot::client()->rpc()->plugins();
$result = $plugins->list(); // Rückgabewert ist 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']));
// Um gleichnamige Direktinstallationen zu unterscheiden, die directSourceId aus list() in names angeben
$plugins->enable(new PluginsEnableRequest(names: ['opaque-direct-source-id']));
$plugins->disable(new PluginsDisableRequest(names: ['opaque-direct-source-id']));

// Verzeichnisse für integrierte Plugins festlegen
$plugins->builtin()->set(new PluginsBuiltinSetRequest(paths: ['/opt/copilot/plugins']));

// Verzeichnisse für alle Sessions, die in der Client-Konfiguration angegeben sind,
// registriert Client::start() automatisch vor dem Erstellen der ersten Session
// config/copilot.php: 'builtin_plugin_directories' => ['/opt/copilot/plugins']

// Marketplace-Verwaltung
$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: Verwaltung benutzerdefinierter Agents)
// Benutzerdefinierte Agents erkennen

$result = Copilot::client()->rpc()->agents()->discover();
// $result->agents ist ein Array von AgentInfo
$result = Copilot::client()->rpc()->agents()->discover(new AgentsDiscoverRequest(
    projectPaths: ['/path/to/project'],
    excludeHostAgents: true,
));

// Verzeichnisse abrufen, in denen Agents erstellt werden können (experimental)

$result = Copilot::client()->rpc()->agents()->getDiscoveryPaths();
// $result->paths ist ein Array von AgentDiscoveryPath
// $result->paths[0]->path - Verzeichnispfad
// $result->paths[0]->scope - Geltungsbereich (user, project, plugin)
// $result->paths[0]->preferredForCreation - Ob es das empfohlene Verzeichnis für Neuanlagen ist
$result = Copilot::client()->rpc()->agents()->getDiscoveryPaths(
    new AgentsGetDiscoveryPathsRequest(scope: 'user')
);

// instructions (experimental: Verwaltung von Instructions)
// Instructions erkennen

$result = Copilot::client()->rpc()->instructions()->discover();
// $result->sources ist ein Array von InstructionSource
$result = Copilot::client()->rpc()->instructions()->discover(
    new InstructionsDiscoverRequest(projectPaths: ['/path/to/project'])
);

// Dateien/Verzeichnisse abrufen, in denen Instructions erstellt werden können (experimental)

$result = Copilot::client()->rpc()->instructions()->getDiscoveryPaths();
// $result->paths ist ein Array von InstructionDiscoveryPath
// $result->paths[0]->path - Datei-/Verzeichnispfad
// $result->paths[0]->location - Ort (user, repository, working-directory, plugin)
// $result->paths[0]->kind - Art (file, directory)
// $result->paths[0]->preferredForCreation - Ob es für Neuanlagen empfohlen ist
$result = Copilot::client()->rpc()->instructions()->getDiscoveryPaths(
    new InstructionsGetDiscoveryPathsRequest(location: 'repository')
);

// extensions (experimental: Verwaltung persistierter Erweiterungen)
$result = Copilot::client()->rpc()->extensions()->discover();
Copilot::client()->rpc()->extensions()->enable(['ids' => ['user:demo']]);
Copilot::client()->rpc()->extensions()->disable(['ids' => ['plugin:demo']]);
```

## Agent-Plugin-Katalogkandidaten

Wenn Sie bei `catalog.search` die Capability `agent-plugin-discovery` anfordern und in den zu durchsuchenden `kinds` den Wert `plugin` angeben, erhalten Sie Agent-Plugin-Kandidaten. Um neben dem Standardformat `application/vnd.github.copilot-plugin` auch `application/vnd.anthropic.claude-plugin+json` und `application/agent-plugin+json` zu empfangen, fordern Sie zusätzlich zu `agent-plugin-discovery` auch `agent-plugin-formats` an.

`agent-plugin-confirmed-installation` ist eine Capability, die die Installierbarkeit und einen Plan zur Überprüfung zurückgibt; auch sie wird zusammen mit `agent-plugin-discovery` angefordert. Wenn sie erlaubt ist, enthalten Kandidaten `installability` mit einem der Werte `installable`, `install-data-unavailable`, `feature-disabled` oder `not-installable-kind`. `installPlan` ist nur enthalten, wenn `installability` den Wert `installable` hat. Der Plan dient lediglich der Überprüfung; dieser Catalog-RPC führt niemals eine Installation aus.

Die `sources` des Plans enthalten Kandidaten in der Prioritätsreihenfolge `materialization`, `marketplace`, `repository`. Für Marketplace werden Name und Repository erfasst, für ein direktes Repository das Repository und ein optionaler Pfad. In einem Plan, der nur aus materialization besteht, wird `pluginName` weggelassen und `components` ist leer. Prüfen Sie Namen und tatsächlich installierte Inhalte in der von `plugins.planInstall()` zurückgegebenen Review.

Für ausgewählte Kandidaten können Sie mit `plugins.planInstall()` einen nebenwirkungsfreien, validierten Plan erstellen. `plugins.applyInstall()` fordert vom Benutzer eine ausdrückliche Bestätigung an und wendet den Plan an, wenn sie erteilt wird. Nach der Anwendung wird das Plugin im deaktivierten Zustand registriert.

Die `mcpServers` der Review zeigen die von den validierten Dateien deklarierten Servernamen, den Transport und bei Remote-Servern den Host. Dies ist keine Sicherheitsgarantie; der Benutzer sollte den Inhalt prüfen, bevor er ausdrücklich bestätigt. Die `description` installierter Plugins stammt aus dem Manifest. `verifiedSource` gibt das GitHub-Repository und einen festen Commit an und ist nur bei direkten, an einen Commit gebundenen Installationen vorhanden. `iconUrl` ist externer, nicht vertrauenswürdiger Inhalt; senden Sie beim Abrufen keine Authentifizierungsdaten oder GitHub-Anmeldeinformationen. Anmeldeinformationen selbst werden nicht als Ablehnungsgrund zurückgegeben.

Bei `network-failure` im Installationsergebnis können Sie `CatalogNetworkFailureReason`, den HTTP-`statusCode`, ein optionales `retryAfterSeconds` und eine sicher anzeigbare `message` prüfen.

```php theme={null}
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,
    ));
}
```

Um aus einer Materialisation Reference von Agent Finder zu planen, verwenden Sie `catalog.planInstallFromReference()`. Das `outcome->kind` des Ergebnisses ist entweder `plugin-install-planned`, `skill-install-planned` oder `refused`. Übergeben Sie Plugin-Pläne an `plugins.applyInstall()` und Skill-Pläne an `skills.applyInstall()`.

```php theme={null}
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\CatalogMaterializationReference;
use Revolution\Copilot\Types\Rpc\CatalogPlanInstallFromReferenceRequest;
use Revolution\Copilot\Types\Rpc\PluginApplyInstallRequest;
use Revolution\Copilot\Types\Rpc\SkillApplyInstallRequest;

$referenceContract = new CatalogClientContract(3, [
    CatalogCapability::CatalogReferenceInstallation->value,
    CatalogCapability::AgentPluginConfirmedInstallation->value,
    CatalogCapability::SkillConfirmedInstallation->value,
]);
$reference = new CatalogMaterializationReference(
    resourceId: '12345',
    revisionId: '67890',
    schemaVersion: '1.0.0',
    descriptorDigest: 'sha256:aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',
    bundleDigest: 'sha256:bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb',
);
$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,
    ));
} elseif ($planned->kind === CatalogReferenceInstallationResultKind::Outcome
    && $planned->outcome?->kind === CatalogReferenceInstallationOutcomeKind::SkillInstallPlanned) {
    Copilot::client()->rpc()->skills()->applyInstall(new SkillApplyInstallRequest(
        contract: $referenceContract,
        planHandle: $planned->outcome->plan['planHandle'],
        policySessionId: $sessionId,
    ));
}
```

## agentRegistry (experimental: Agent-Registry)

Erstellt, listet und entfernt Einträge der Agent-Registry. Das Ergebnis der Auflistung enthält keine Verbindungsanmeldeinformationen.

```php theme={null}
use Revolution\Copilot\Facades\Copilot;
use Revolution\Copilot\Types\Rpc\AgentRegistryEnsureDirRequest;
use Revolution\Copilot\Types\Rpc\AgentRegistryListEntriesRequest;
use Revolution\Copilot\Types\Rpc\AgentRegistryRemoveEntryRequest;

$homeDir = '/home/user';

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

## LSP (serverweite Language-Server-Einstellungen)

`lsp()` listet die serverweiten Einstellungen der Language Server auf. Für sessionbezogene Initialisierung, Start, Stopp und ähnliche Operationen verwenden Sie `lsp()` von SessionRpc (Anwendungsbeispiele unter [Workspaces, Agents, Fleet und Skills](https://kawax.biz/de/packages/laravel-copilot-sdk/rpc/session-workspace.md)).

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

// Serverweite Language-Server-Einstellungen auflisten
$serverConfigs = Copilot::client()->rpc()->lsp()->list([
    'workingDirectory' => base_path(),
]);
```


## Related topics

- [ServerRpc-Übersicht](https://kawax.biz/de/packages/laravel-copilot-sdk/rpc/server-overview.md)
- [RPC (Remote Procedure Call)](https://kawax.biz/de/packages/laravel-copilot-sdk/rpc.md)
- [laravel/agent-skills – Offizielle KI-Agent-Skills-Sammlung von Laravel](https://kawax.biz/de/blog/agent-skills-introduction.md)
- [Plugins und Extensions](https://kawax.biz/de/packages/laravel-copilot-sdk/rpc/session-plugins.md)
- [Workspaces, Agents, Fleet und Skills](https://kawax.biz/de/packages/laravel-copilot-sdk/rpc/session-workspace.md)


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.