---
url: https://docs.ogmabox.com/fr/reference/mcp-tools.md
description: >-
  Référence complète d'Ogma MCP présentant les fonctions et paramètres des
  outils, les ressources, les prompts, les autorisations, la pagination et le
  traitement des résultats.
---

# Ressources et outils MCP {#mcp-resources-and-tools}

Le serveur MCP d'Ogma est destiné aux clients MCP externes tels que Codex, Claude Code, Cursor et d'autres hôtes Model Context Protocol. Il est distinct de l'assistant IA intégré à l'application.

MCP expose quatre interfaces de découverte :

* **Ressources** : cibles de lecture nommées qu'un client MCP peut ouvrir.
* **Modèles de ressources** : cibles de lecture paramétrées pour une entrée, un constat, un workflow, une exécution, un export ou un objet Rejeu précis.
* **Outils** : actions appelables. Certaines sont en lecture seule. D'autres nécessitent des options au démarrage du serveur.
* **Prompts** : instructions réutilisables qui aident un agent à planifier une inspection, un nouveau test ou un rapport. Récupérer un prompt n'exécute pas ses outils.

Pour les points de connexion et la configuration des clients, voir [Configuration MCP](../mcp-setup.md). Pour une séquence d'interaction de bout en bout, voir [Automatisation du navigateur avec MCP](../guide/mcp-browser.md).

Cette référence couvre l'implémentation actuelle : **255 outils**, 17 ressources, 9 modèles de ressources et 12 prompts. Tous les outils sont annoncés ; les contrôles d'autorisation s'appliquent toujours lors de leur appel. Les versions installées plus anciennes peuvent exposer moins d'outils. Découvrez le catalogue de votre serveur en cours d'exécution avant de choisir un outil.

## Méthodes du protocole {#protocol-methods}

Il s'agit de noms de méthodes JSON-RPC, et non de chemins d'URL distincts. Un client MCP gère le cycle de vie de la connexion via [HTTP ou stdio](../mcp-setup.md#connection-addresses).

| Méthode | Fonction |
| --- | --- |
| `initialize` | Négocier la version du protocole et les capacités du serveur et du client. |
| `notifications/initialized` | Indiquer au serveur que l'initialisation est terminée ; cette notification n'a pas d'identifiant de requête. |
| `tools/list` | Découvrir les outils et les schémas de leurs arguments en suivant `nextCursor`. |
| `tools/call` | Exécuter un outil avec `name` et `arguments`. |
| `resources/list` | Lister les ressources nommées en lecture seule. |
| `resources/templates/list` | Lister les modèles d'URI pour lire des objets individuels. |
| `resources/read` | Lire une ressource avec son `uri` complet. |
| `prompts/list` | Découvrir les prompts réutilisables et leurs arguments. |
| `prompts/get` | Récupérer les messages d'un prompt avec `name` et des arguments textuels facultatifs. |

## Découvrir et appeler les outils {#discover-and-call-tools}

Les noms tels que `ogma_search_http_history` sont des identifiants d'outils MCP, et non des routes HTTP individuelles. Appelez-les via `tools/call` sur votre connexion MCP.

1. Initialisez la connexion avec votre client MCP.
2. Appelez `tools/list`. Ogma renvoie jusqu'à **40 outils par page**. Renvoyez chaque `nextCursor` reçu dans `params.cursor` jusqu'à son absence ; sinon, la plupart des outils du navigateur manqueront dans le client.
3. Lisez l'`inputSchema` de chaque outil pour connaître les types de champs, les valeurs d'énumération, les valeurs par défaut, les limites et les formats des objets imbriqués. N'inventez pas d'arguments à partir du nom de l'outil.
4. Lisez `ogma://mcp/permissions` et `ogma://mcp/tool-guide` avant d'agir.
5. Appelez l'outil choisi avec un objet JSON dans `arguments`.

Exemple de requête JSON-RPC sur une connexion initialisée :

```json
{
  "jsonrpc": "2.0",
  "id": 2,
  "method": "tools/call",
  "params": {
    "name": "ogma_search_http_history",
    "arguments": {
      "q": "req.host.eq:\"example.com\"",
      "limit": 20,
      "offset": 0
    }
  }
}
```

Utilisez les identifiants renvoyés par les outils de liste ou de recherche au lieu de les deviner. Les recherches dans l'historique et les constats utilisent `limit`/`offset` ; les outils de delta du navigateur utilisent `since_entry_id`. Aucun de ces mécanismes n'est le curseur opaque utilisé par `tools/list`.

## Lire les résultats {#reading-results}

Privilégiez `result.structuredContent`. Le bloc de contenu textuel contient la même enveloppe JSON pour les clients qui ne prennent en charge que les résultats textuels. Exception : le résultat par défaut d'`ogma_browser_snapshot` n'a pas de contenu structuré, et son contenu textuel est l'arborescence lisible ; utilisez `result_detail: "full"` pour ses éléments structurés. Dans la passerelle REST locale, analysez plutôt la chaîne JSON de `result` ; cette passerelle n'est pas le transport MCP.

Lorsqu'un outil échoue via la passerelle REST, la valeur analysée est `{ "error": "..." }`, avec l'enveloppe d'erreur sérialisée de l'outil dans cette chaîne. Un statut HTTP de succès de la passerelle ne signifie pas à lui seul que l'outil a réussi.

| Champ de l'enveloppe | Signification |
| --- | --- |
| `ok` | Indique si l'opération de l'outil a réussi. Examinez aussi `isError` dans le résultat MCP. |
| `workflow_stage`, `summary` | Contexte de l'opération et brève explication. |
| `evidence`, `hypotheses` | Preuves observées et interprétations distinctes, non confirmées. |
| `next_actions`, `use_next_tools` | Travaux complémentaires suggérés et choix des outils suivants. |
| `artifacts` | Références aux preuves ou fichiers générés, lorsqu'ils sont disponibles. |
| `raw` | Données propres à l'outil. Présentes dans les résultats structurés ; les outils compacts ne les incluent qu'avec `result_detail: "full"`. Il peut s'agir d'un objet, d'un tableau ou de texte ; ne supposez pas une structure universelle. |

Les outils de capture d'écran renvoient aussi un bloc d'image MCP natif. Lisez ce bloc plutôt que de chercher des données d'image en Base64 dans les métadonnées JSON. Un instantané du navigateur renvoie par défaut une arborescence textuelle compacte ; fournissez `result_detail: "full"` pour obtenir ses éléments structurés dans `raw.elements`. Les deltas réseau et console du navigateur contiennent des entrées structurées.

Un appel de validation réussi peut tout de même renvoyer `valid: false` dans ses données. Un échec d'exécution d'outil utilise `isError: true` ; les requêtes de protocole invalides utilisent les erreurs JSON-RPC. Lisez le diagnostic avant de réessayer. Les erreurs du backend peuvent inclure un statut HTTP, un point de terminaison et un texte de diagnostic de longueur limitée ; `[truncated]` signifie que le diagnostic a été raccourci, et non que l'opération a réussi.

Ces conventions de résultat utilisent le [format des résultats d'outils](https://modelcontextprotocol.io/specification/2025-11-25/server/tools#tool-result) de MCP.

## Ressources {#resources}

| Ressource | Contenu renvoyé |
| --- | --- |
| `ogma://status` | Santé et état actuels du backend. |
| `ogma://projects` | Tous les projets Ogma. |
| `ogma://project/current` | Projet actuellement actif. |
| `ogma://instances` | Instances d'écoute du proxy. |
| `ogma://http-history/recent` | Les 20 entrées HTTP les plus récentes, sans le contenu des corps. |
| `ogma://ws-history/recent` | Les 20 connexions WebSocket les plus récentes. |
| `ogma://findings` | Jusqu'à 50 constats. |
| `ogma://workflows` | Workflows configurés. |
| `ogma://workflow-runs/recent` | Les 20 enregistrements d'exécution de workflows les plus récents. |
| `ogma://migration/workflows` | Rapport de compatibilité pour la migration des workflows. |
| `ogma://exports/recent` | Les 10 tâches d'export les plus récentes. |
| `ogma://capabilities` | Résumé des capacités du serveur MCP. |
| `ogma://mcp/permissions` | Options d'autorisation MCP actuelles. |
| `ogma://mcp/tool-guide` | Choix des outils pour l'agent, conventions de sortie et séquences recommandées pour le navigateur et les tests. |
| `ogma://mcp/report-guide` | Séquence d'assemblage du rapport, exigences de preuve et contrôles qualité. |
| `ogma://mcp/resume` | Contexte de reprise durable pour le projet actif : points de reprise enregistrés et activité récente des outils. |
| `ogma://replay/sessions/recent` | Les 20 sessions Rejeu les plus récentes. |

## Modèles de ressources {#resource-templates}

| Modèle | Contenu renvoyé |
| --- | --- |
| `ogma://http-history/{entry_id}` | Une entrée d'historique HTTP. |
| `ogma://ws-history/{connection_id}` | Une connexion WebSocket. |
| `ogma://findings/{finding_id}` | Un constat. |
| `ogma://workflows/{workflow_id}` | Un workflow. |
| `ogma://workflow-runs/{run_id}` | Une exécution de workflow. |
| `ogma://exports/{export_id}` | Une tâche d'export. |
| `ogma://replay/sessions/{session_id}` | Une session Rejeu. |
| `ogma://replay/attempts/{session_id}/{attempt_id}` | Une tentative Rejeu. |
| `ogma://workflow-safety/{workflow_id}` | Classification de sécurité du workflow et autorisations requises. |

Lisez ces URI avec `resources/read`, et non avec une requête HTTP GET vers `ogma://`. Remplacez l'identifiant dans un modèle de ressource avant de le lire. Les ressources renvoient du texte dans `contents` ; elles n'utilisent pas l'enveloppe de résultat d'outil décrite ci-dessus.

## Prompts {#prompts}

Découvrez-les avec `prompts/list`, puis utilisez `prompts/get` avec `name` et un objet `arguments`. Les valeurs des arguments de prompt sont des chaînes de caractères. Les arguments obligatoires sont en gras ci-dessous.

| Prompt | Arguments | Préparation effectuée |
| --- | --- | --- |
| `analyze_http_entry` | **`entry_id`** | Examiner un échange HTTP capturé pour rechercher des problèmes de sécurité étayés par des preuves. |
| `summarize_project_security_state` | Aucun | Résumer les constats et les priorités de correction du projet actif. |
| `triage_findings` | `severity` | Hiérarchiser les constats, éventuellement pour un seul niveau de gravité. |
| `investigate_suspicious_host` | **`host`** | Examiner le trafic capturé pour un nom d'hôte ou une IP. |
| `review_workflow_migration_report` | Aucun | Expliquer les problèmes de compatibilité des workflows et les étapes de migration. |
| `generate_retest_plan` | **`finding_id`** | Préparer les étapes de reproduction et les critères de réussite ou d'échec d'un constat. |
| `create_finding_from_http_evidence` | **`entry_id`** | Analyser les preuves et guider la création d'un constat lorsque cela est autorisé. |
| `prepare_evidence_export` | **`export_kind`** | Planifier un export `http_history`, `findings` ou `automate_results`. |
| `retest_http_entry_with_replay` | **`entry_id`** | Guider la séquence de prévisualisation et de confirmation de Rejeu. |
| `run_workflow_safely` | **`workflow_id`** | Examiner les effets de bord d'un workflow, prévisualiser son exécution et l'exécuter lorsque cela est autorisé. |
| `pentest_web_target` | **`target_url`**, `objective` | Planifier un audit par étapes d'une cible autorisée, guidé par les preuves. |
| `solve_web_challenge` | **`challenge_url`**, `goal` | Planifier l'investigation d'un défi web et la collecte de preuves. |

## Autorisations des outils {#tool-permissions}

La plupart des outils d'inspection sont toujours disponibles. Les actions de modification ou les actions sortantes sont contrôlées par les options de démarrage d'`ogma-mcp` :

| Option d'autorisation | Actions permises |
| --- | --- |
| `--allow-write-findings` | Écriture des constats et génération de rapports ; permet aussi les modifications partagées du projet, notamment des variables d'environnement et des règles Rechercher et remplacer. |
| `--allow-export-data` | Création de tâches d'export. La lecture des métadonnées d'exports existants et des informations de téléchargement ne nécessite pas cette option. |
| `--allow-read-secrets` | Lecture des valeurs non masquées des variables d'environnement. Cette autorisation est distincte de celle de modifier les variables. |
| `--allow-send-requests` | Envois Rejeu et Automatisation, requêtes directes ou par lots, interactions du navigateur, découverte, exploration, parcours d'authentification, sondes actives, WebSockets et changement de projet. |
| `--allow-run-workflows` | Outils de prévisualisation, d'exécution et d'annulation des workflows. L'exécution d'Automatisation utilise plutôt l'autorisation d'envoi. |
| `--allow-intercept-control` | Lecture de l'état et de la file d'interception, modification de la file et contrôle de l'état d'interception. |

Les autorisations sont vérifiées lors de l'appel d'un outil ; sa présence dans la liste ne signifie pas que ses actions sont permises. Les outils d'observation du navigateur peuvent examiner un navigateur déjà lancé, mais le piloter et gérer ses contextes nécessite `allow_send_requests`. Les parcours d'authentification nécessitent également cette autorisation, y compris les appels de liste et de vérification. Les notes et tâches locales à la session ne nécessitent pas d'autorisation d'écriture dans le projet.

Il n'existe aucun quota d'activité par minute ou par session. Chaque outil impose toutefois ses propres limites de taille d'entrée, de taille de lot, de délai et de périmètre. L'exécution d'un workflow peut nécessiter des autorisations supplémentaires d'envoi ou d'écriture des constats selon ses opérations. Voir [Configuration et autorisations](../mcp-setup.md#permissions).

Tous les outils sont annoncés, quelles que soient les autorisations. Les anciennes options de profil ne filtrent plus la liste des outils. Voir [Découverte et invocation des outils](#tool-discovery-and-dispatch).

## Catalogue des outils {#tool-catalog}

### Reprendre après une perte de contexte {#recovering-after-context-loss}

Après une reconnexion ou une perte du contexte de conversation, appelez `ogma_resume_session` avant de commencer un autre audit. Vérifiez le projet actif, le dernier point de reprise et les résultats récents des outils. Utilisez `check_live: true` pour des vérifications limitées en lecture seule des références enregistrées ; cela ne répète pas les actions. Actualisez les instantanés du navigateur avant de réutiliser les références d'éléments.

Enregistrez un point de reprise avant une passation ou une longue pause. L'activité des outils consigne ce qui a été exécuté ; elle ne peut pas déduire le prochain test que vous aviez prévu. Explicitez l'objectif, les conclusions, les incertitudes et les prochaines étapes, et référencez les preuves par identifiant au lieu de copier des corps de réponse volumineux dans le point de reprise.

```json
{
  "name": "ogma_save_checkpoint",
  "arguments": {
    "assessment_id": "authorization-review",
    "objective": "Compare access to invoices across two test identities",
    "progress": "Captured the owner request; the second identity has not been tested yet",
    "next_steps": ["Resume the saved context", "Verify the active project and both identities before replaying"],
    "uncertainties": ["Whether the server checks invoice ownership"]
  }
}
```

```json
{
  "name": "ogma_resume_session",
  "arguments": {
    "assessment_id": "authorization-review",
    "check_live": true
  }
}
```

Enregistrez un point de reprise avant une passation ou une réduction du contexte de conversation. Consignez explicitement votre objectif, le travail terminé, les incertitudes, les identifiants de preuve et les prochaines étapes : le journal d'activité automatique stocke les références et les résultats, pas les charges utiles des requêtes ni votre intention. Un appel commencé sans résultat final a une issue inconnue ; examinez l'état actuel avant de réessayer un envoi.

Les enregistrements de reprise sont durables et propres au projet. Avec `assessment_id`, les lectures sont limitées à cet audit ; omettez-le lors des lectures de reprise pour examiner l'activité de tout le projet. Les notes et tâches existantes, locales à la session, ont une autre fonction et ne doivent pas être confondues avec une passation durable.

| Outil | Fonction | Paramètres |
| --- | --- | --- |
| `ogma_save_checkpoint` | Ajoute une passation durable. `next_steps` est un tableau d'actions explicites ; `references` associe des noms à des identifiants enregistrés. N'exécute pas le plan. | **`objective`**, **`progress`**, **`next_steps`**, `uncertainties`, `references` |
| `ogma_resume_session` | Lit le projet actif, le dernier point de reprise, l'activité récente et les indications de reprise. Des vérifications en direct facultatives examinent les références enregistrées sans répéter les actions. | `check_live` |
| `ogma_get_session_activity` | Lit les points de reprise et l'activité des outils, du plus récent au plus ancien. Les dates sont en millisecondes Unix UTC. Pour paginer, fournissez à la fois `before_ms` et `before_id` issus du curseur renvoyé. | `kind`, `id`, `since_ms`, `until_ms`, `before_ms`, `before_id`, `search`, `limit` |

Chaque ligne explique l'outil et liste ses paramètres de premier niveau. **Les paramètres en gras sont obligatoires selon son schéma** ; les autres sont facultatifs. Certains outils exigent un choix entre plusieurs paramètres (par exemple, une source Rejeu ou une cible de clic) ; leurs descriptions et leur validation à l'exécution expliquent ces combinaisons. Pour les champs imbriqués et les types exacts, lisez l'`inputSchema` de l'outil en cours d'exécution.

Chaque outil accepte aussi un `assessment_id` facultatif (chaîne non vide de 200 caractères maximum). Réutilisez-le pour regrouper le contexte de reprise d'un même audit. Il ne change pas le projet actif et n'accorde aucune autorisation. Ce paramètre commun n'est pas répété dans les tableaux ci-dessous.

### Découverte et invocation des outils {#tool-discovery-and-dispatch}

Le serveur annonce tous les outils enregistrés. Utilisez les outils de découverte des capacités et des contrats pour identifier une opération et examiner ses paramètres avant de l'appeler ; aucun changement de profil n'est nécessaire pour l'exposer. Voir [Configuration MCP](../mcp-setup.md#tool-discovery).

Utilisez `ogma_browser` pour les actions du navigateur intégré (`snapshot`, `fill_input`, `fill_form`, `console_delta`, `network_delta` et le reste de la famille navigateur) et `ogma_search` pour les domaines de recherche tels que `http_history`, `findings` et `ws_history`. Les outils dédiés équivalents restent disponibles.

| Outil | Fonction | Paramètres |
| --- | --- | --- |
| `ogma_find_tools` | Recherche dans tout le catalogue par mots-clés de tâche. Une recherche portant sur un nom d'outil exact renvoie son contrat complet ; `include_schema` demande aussi les contrats des correspondances par mots-clés. Tous les mots recherchés doivent correspondre, et un résultat tronqué ou vide ne prouve pas l'absence d'une capacité. Limite par défaut : 5 ; maximum : 10. | **`query`**, `limit`, `include_schema` |
| `ogma_call_tool` | Exécute un outil Ogma enregistré par son nom. Les paramètres autres que `tool` sont transmis à l'outil nommé ; ses autorisations continuent de s'appliquer. | **`tool`** |
| `ogma_browser` | Pilote le navigateur intégré par nom d'action. Tout autre outil `ogma_browser_*` est accessible par le suffixe de son nom, par exemple `action: "snapshot"` pour `ogma_browser_snapshot`. | **`action`**, `selector`, `tab_id`, `url`, `js`, `text`, `value`, `key`, `cookie`, `timeout_ms` |
| `ogma_search` | Recherche dans les domaines de données Ogma via un point d'entrée unique. Tout autre outil `ogma_search_*` est accessible par le suffixe de son nom. | **`domain`**, `q`, `limit`, `offset` |

### Historique HTTP et requêtes de recherche {#http-history-and-querying}

| Outil | Fonction | Paramètres |
| --- | --- | --- |
| `ogma_search_http_history` | Recherche dans l'historique HTTP avec HTTPQL et renvoie les métadonnées des requêtes et réponses. | `q`, `limit`, `offset`, `result_detail` |
| `ogma_get_http_entry` | Récupère une entrée HTTP par identifiant, avec des aperçus des corps en option. | **`entry_id`**, `include_body_preview`, `result_detail` |
| `ogma_get_http_entry_body` | Récupère le corps complet de la requête et/ou de la réponse d'une entrée HTTP. | **`entry_id`**, **`part`**, `search_pattern`, `result_detail` |
| `ogma_validate_httpql` | Valide une expression HTTPQL. | **`query`** |
| `ogma_analyze_http_entry_security` | Examine une entrée HTTP pour rechercher des comportements et des preuves pertinents pour la sécurité. | **`entry_id`** |
| `ogma_search_by_vulnerability_pattern` | Recherche des motifs associés à des vulnérabilités dans le trafic capturé. | **`pattern_type`**, `limit` |

### WebSocket et SSE {#websocket-and-sse}

| Outil | Fonction | Paramètres |
| --- | --- | --- |
| `ogma_search_ws_history` | Recherche dans l'historique des connexions WebSocket avec StreamQL. | `q`, `limit`, `offset` |
| `ogma_get_ws_messages` | Récupère les messages stockés d'une connexion WebSocket. | **`connection_id`**, `limit`, `offset` |
| `ogma_get_ws_message` | Lit un message complet sans la troncature des aperçus de liste ; le texte est en UTF-8, les charges utiles binaires ou de contrôle en Base64. | **`message_id`** |
| `ogma_validate_streamql` | Valide une expression StreamQL. | **`query`** |
| `ogma_get_ws_messages_live` | Récupère les messages WebSocket en direct capturés par l'instrumentation du navigateur. | `host`, `limit` |
| `ogma_create_ws_replay_session` | Crée une session Rejeu WebSocket. | **`ws_connection_id`** |
| `ogma_connect_ws_replay` | Connecte une session Rejeu WebSocket. | **`ws_session_id`** |
| `ogma_send_ws_replay_message` | Envoie un message via une session Rejeu WebSocket. | **`ws_session_id`**, **`payload`**, `message_type` |
| `ogma_list_ws_replay_sessions` | Liste les sessions Rejeu WebSocket. | `result_detail` |
| `ogma_get_ws_replay_messages` | Lit la transcription d'une session Rejeu WebSocket, et non l'historique capturé. Omettez `cursor` pour commencer ; fournissez le `next_cursor` renvoyé et poursuivez tant que `has_more` l'indique. | **`ws_session_id`**, `cursor`, `limit`, `result_detail` |
| `ogma_get_ws_replay_message` | Lit un message Rejeu WebSocket sans troncature de l'aperçu de charge utile ; `payload_base64` indique des octets encodés en Base64. | **`message_id`**, `result_detail` |
| `ogma_disconnect_ws_replay` | Déconnecte une session Rejeu WebSocket en conservant la session et sa transcription ; annule aussi une connexion en attente. | **`ws_session_id`** |
| `ogma_browser_get_ws_frames` | Lit les trames WebSocket capturées par le navigateur intégré. | `limit`, `connection_url`, `direction` |
| `ogma_browser_start_ws_capture` | Démarre la capture des trames WebSocket côté navigateur. | Aucun. |
| `ogma_browser_send_ws_message` | Envoie un message WebSocket depuis le contexte du navigateur. | **`payload`**, `connection_url` |

### Constats et preuves {#findings-and-evidence}

| Outil | Fonction | Paramètres |
| --- | --- | --- |
| `ogma_search_findings` | Recherche les constats par gravité, auteur, texte, limite et décalage. | `severity`, `reporter`, `q`, `limit`, `offset` |
| `ogma_get_finding` | Récupère un constat par identifiant. | **`finding_id`** |
| `ogma_preview_finding_from_evidence` | Prévisualise un brouillon de constat à partir d'une entrée HTTP sans le créer. | **`entry_id`**, `reporter` |
| `ogma_create_finding` | Crée un constat avec des métadonnées, des étiquettes, un niveau de confiance, des mesures de correction et des liens de preuve facultatifs. | **`title`**, `severity`, `status`, `description`, `reporter`, `tags`, `dedupe_key`, `entry_id`, `replay_attempt_id`, `automate_result_id`, `ws_message_id`, `confidence`, `remediation`, `skip_dedup_check` |
| `ogma_update_finding` | Met à jour un constat existant. | **`finding_id`**, **`title`**, `severity`, `status`, `description`, `reporter`, `tags`, `dedupe_key`, `confidence`, `remediation` |
| `ogma_add_finding_tag` | Ajoute des étiquettes à un constat sans remplacer les étiquettes existantes. | **`finding_id`**, **`tags`** |
| `ogma_link_finding_evidence` | Ajoute à un constat des preuves HTTP, Rejeu, Automatisation, de messages WebSocket capturés ou de Rejeu WebSocket. Les liens complémentaires ne remplacent pas sa preuve principale. | **`finding_id`**, `entry_id`, `replay_attempt_id`, `automate_result_id`, `ws_message_id`, `ws_replay_message_id` |
| `ogma_delete_finding` | Supprime un constat. | **`finding_id`** |
| `ogma_create_finding_from_entry` | Crée un constat à partir d'une entrée HTTP capturée. Intègre les en-têtes et corps de la requête et de la réponse comme preuves HTTP en Markdown, avec un corps de réponse tronqué à 3000 caractères. Ajoute un score CVSS calculé à partir d'une décomposition fournie, un CWE, du code de preuve de concept et des références. | **`entry_id`**, **`title`**, **`severity`**, **`vulnerability_type`**, **`description`**, **`impact`**, **`remediation`**, `confidence`, `reporter`, `tags`, `affected_parameter`, `proof_of_concept`, `cvss_breakdown`, `cwe`, `poc_code`, `references`, `skip_dedup_check` |
| `ogma_get_finding_evidence_summary` | Résume les preuves liées à un constat. | **`finding_id`** |
| `ogma_record_finding_verification` | Enregistre le verdict d'un nouveau test indépendant pour un constat : `verified`, `refuted` ou `inconclusive`. Le verdict le plus récent fait foi : une réfutation ultérieure remplace donc une confirmation antérieure, et l'outil rapporte la ligne enregistrée. | **`finding_id`**, **`state`**, **`method`**, **`reason`**, `evidence_entry_id`, `control_entry_id`, `canary_id` |
| `ogma_check_canary` | Crée un jeton avec `label` et `purpose`, ou revérifie un jeton existant avec `canary_id` sans en créer un autre. Recherche les entrées correspondantes dans le trafic capturé. Une correspondance dans le corps d'une réponse prouve la relecture du jeton ; une correspondance dans le corps d'une requête montre seulement qu'il a été envoyé. | **`canary_id`** ou **`label`** et **`purpose`**, `finding_id`, `hosted_path`, `limit` |
| `ogma_export_findings_report` | Crée un export de rapport de constats. | **`format`**, `title`, `summary`, `scope`, `tester`, `include_evidence` |

### Exports {#exports}

| Outil | Fonction | Paramètres |
| --- | --- | --- |
| `ogma_preview_export_plan` | Prévisualise le contenu et le format d'un export sans créer de tâche. | **`kind`**, **`format`**, `limit`, `q`, `severity`, `reporter` |
| `ogma_create_export_job` | Crée une tâche d'export pour l'historique, les résultats de recherche, les constats ou les résultats Automatisation. | **`name`**, **`kind`**, **`format`**, `limit`, `offset`, `scope`, `q`, `severity`, `reporter`, `run_id` |
| `ogma_get_export_job` | Récupère une tâche d'export par identifiant. | **`export_id`** |
| `ogma_list_export_jobs` | Liste les tâches d'export. | `limit`, `offset` |
| `ogma_get_export_download_info` | Récupère les métadonnées de téléchargement d'un export terminé. | **`export_id`** |

### Rejeu et envoi de requêtes {#replay-and-request-sending}

| Outil | Fonction | Paramètres |
| --- | --- | --- |
| `ogma_preview_replay_send` | Prévisualise un envoi Rejeu et renvoie un jeton de confirmation. | `http_entry_id`, `replay_session_id`, `method`, `path`, `query`, `body`, `result_detail` |
| `ogma_send_replay_request` | Envoie une requête Rejeu avec le jeton de confirmation. | **`confirmation_token`**, **`request_hash`**, `result_detail` |
| `ogma_create_replay_session_from_history` | Crée une session Rejeu à partir d'une entrée HTTP capturée. | **`entry_id`**, `name`, `result_detail` |
| `ogma_create_replay_session_raw` | Crée une session Rejeu à partir d'une définition de requête brute. | `name`, **`host`**, **`port`**, `tls`, `method`, `path`, `headers`, `body` |
| `ogma_get_replay_session` | Récupère les métadonnées d'une session Rejeu et une liste paginée des tentatives. | **`session_id`**, `attempts_limit`, `attempts_offset`, `result_detail` |
| `ogma_get_replay_attempt` | Récupère une tentative Rejeu. | **`session_id`**, **`attempt_id`**, `result_detail` |
| `ogma_list_replay_sessions` | Liste les sessions Rejeu. | `limit`, `offset`, `result_detail` |
| `ogma_create_replay_sequence` | Crée une séquence Rejeu en plusieurs étapes à partir de sessions Rejeu existantes, dans l'ordre d'exécution des étapes ; `collection_id` applique les variables de cette collection pendant une exécution. | **`name`**, **`session_ids`**, `collection_id` |
| `ogma_run_replay_sequence` | Exécute une séquence Rejeu enregistrée, ce qui envoie du trafic sortant réel. `plan` liste les indices des étapes dans l'ordre d'exécution ; les entrées peuvent répéter, omettre ou réordonner des étapes, et l'absence de `plan` exécute chaque étape enregistrée une fois dans l'ordre. Un `plan` vide est refusé. | **`sequence_id`**, `plan` |
| `ogma_repeat_request` | Répète une requête existante avec des modifications facultatives. | **`request_id`**, `params`, `headers`, `body`, `cookies`, `url`, `method`, `method_override`, `path`, `path_override`, `entry_id`, `headers_add`, `headers_remove`, `body_text`, `body_json`, `body_b64`, `body_base64`, `raw_request_base64`, `result_detail` |
| `ogma_replay_with_modifications` | Rejoue une requête HTTP capturée avec des substitutions de champs et renvoie une réponse accompagnée d'un résumé des différences. | **`entry_id`**, `method_override`, `path_override`, `headers_add`, `headers_remove`, `body`, `body_text`, `body_json`, `body_b64`, `body_base64`, `raw_request_base64`, `request_id`, `method`, `path`, `headers`, `follow_redirects`, `timeout_secs`, `result_detail` |
| `ogma_http_request` | Envoie une requête HTTP directe via l'interface d'outils MCP. Avec `raw_request_base64`, `max_responses` lit plusieurs trames de réponse sur la même connexion au lieu de s'arrêter à la première, et `followup_raw_request_base64` écrit une requête sur cette connexion après la lecture de la première réponse ; une réponse que les octets envoyés n'ont pas sollicitée permet de confirmer une désynchronisation de requêtes plutôt que de la supposer. Ces deux paramètres ne s'appliquent qu'au mode brut. | **`host`**, `port`, `tls`, `method`, `path`, `headers`, `body_b64`, `method_override`, `path_override`, `headers_add`, `headers_remove`, `body`, `body_text`, `body_json`, `body_base64`, `raw_request_base64`, `max_responses`, `followup_raw_request_base64`, `result_detail` |
| `ogma_bulk_send_requests` | Envoie un lot de requêtes. | **`base_session_id`**, **`payloads`**, **`placeholder`**, `max_requests` |
| `ogma_fetch_url` | Récupère une URL et renvoie le statut de la réponse, les en-têtes et un aperçu du corps. | **`url`**, `method`, `headers`, `body_b64`, `max_bytes` |
| `ogma_follow_redirect` | Récupère une URL, suit la chaîne de redirections et rapporte chaque saut. | **`url`**, `method`, `headers`, `body_b64`, `max_hops`, `timeout_secs` |
| `ogma_fuzz_parameter` | Remplace un marqueur `{{FUZZ}}` par les valeurs d'une liste de mots et regroupe les réponses par statut et taille. | **`url`**, `method`, `headers`, `body_template`, **`wordlist`**, `timeout_secs`, `stop_on_match` |
| `ogma_multipart_upload` | Envoie des requêtes multipart form-data avec des champs textuels et des fichiers pour tester les téléversements. | **`url`**, **`fields`**, `headers`, `timeout_secs` |
| `ogma_test_login` | Teste un point de terminaison de connexion avec des paires d'identifiants fournies ou par défaut et rapporte les preuves. | **`url`**, `credentials`, `username_field`, `password_field`, `submit_selector`, `success_pattern`, `failure_pattern`, `max_attempts` |

### Workflows et Automatisation {#workflows-and-automate}

| Outil | Fonction | Paramètres |
| --- | --- | --- |
| `ogma_search_workflows` | Liste et filtre les workflows. | `workflow_type`, `enabled`, `limit`, `offset` |
| `ogma_get_workflow` | Récupère un workflow par identifiant. | **`workflow_id`** |
| `ogma_get_workflow_run` | Récupère un enregistrement d'exécution de workflow. | **`run_id`** |
| `ogma_validate_workflow_import` | Valide la compatibilité d'import d'un paquet de workflows. | **`bundle_json`** |
| `ogma_get_workflow_safety` | Récupère la classification de sécurité et d'autorisation d'un workflow. | **`workflow_id`** |
| `ogma_preview_workflow_run` | Prévisualise une exécution de workflow avant de l'effectuer. | **`workflow_id`**, `input`, `trigger_entry_id` |
| `ogma_run_workflow` | Exécute un workflow. | **`confirmation_token`**, **`definition_hash`**, `input_hash`, `input` |
| `ogma_cancel_workflow_run` | Annule une exécution de workflow. | **`run_id`** |
| `ogma_list_automate_sessions` | Liste les sessions Automatisation. | `limit`, `offset` |
| `ogma_get_automate_session` | Récupère une session Automatisation. | **`session_id`** |
| `ogma_create_automate_session` | Crée une session Automatisation avec un point d'injection. `inject_into` le sélectionne sous la forme `query:<name>`, `header:<name>` ou `body` ; par défaut, il s'agit du premier paramètre de la chaîne de requête, puis du corps. | **`entry_id`**, `name`, **`payloads`**, `inject_into`, `placeholder_start`, `placeholder_end`, `worker_count`, `delay_ms` |
| `ogma_run_automate_session` | Exécute une session Automatisation. | **`session_id`** |
| `ogma_list_automate_runs` | Liste les exécutions Automatisation. | **`session_id`**, `limit`, `offset` |
| `ogma_get_automate_run` | Récupère une exécution Automatisation. | **`run_id`** |
| `ogma_cancel_automate_run` | Annule une exécution Automatisation. | **`run_id`** |
| `ogma_list_automate_results` | Liste les résultats Automatisation. | **`run_id`**, `limit`, `offset`, `min_status`, `max_status` |
| `ogma_get_automate_result` | Récupère un résultat Automatisation. | **`run_id`**, **`seq`** |
| `ogma_load_skill` | Charge les instructions des compétences MCP intégrées dans le contexte de l'assistant. | **`skills`** |

### Scanner {#scanner}

Le lancement d'analyses passives ou actives nécessite l'autorisation d'écriture des constats, car les analyses peuvent en créer. La liste des règles du scanner et des catégories de vérifications actives ne nécessite pas cette autorisation.

| Outil | Fonction | Paramètres |
| --- | --- | --- |
| `ogma_run_passive_scan` | Exécute les vérifications du scanner passif sur une entrée HTTP. | **`entry_id`** |
| `ogma_run_passive_scan_all` | Exécute les vérifications du scanner passif sur tout l'historique capturé. | Aucun. |
| `ogma_list_scanner_rules` | Liste les règles de détection du scanner. | Aucun. |
| `ogma_list_active_checks` | Liste les catégories de vérifications du scanner actif avec leurs identifiants et descriptions, et indique combien d'entre elles créent des constats. Les catégories non implémentées sont listées, mais ne produisent jamais de constat. | Aucun. |
| `ogma_scan_active` | Exécute le scanner actif, qui envoie des charges utiles de preuve et ne crée des constats que pour les classes qu'il confirme à partir de la réponse. Fournissez `entry_id` pour analyser une entrée, ou omettez-le pour parcourir l'historique récent. L'opération étant longue, elle est exposée comme une tâche ; le chemin synchrone interroge cette tâche jusqu'à un état terminal et rapporte `job_id`, les compteurs de progression et `findings_created`. Nécessite l'autorisation d'écriture des constats. | `entry_id`, `checks`, `concurrency`, `delay_ms`, `scan_headers` |

### Interception {#intercept}

| Outil | Fonction | Paramètres |
| --- | --- | --- |
| `ogma_get_intercept_status` | Récupère l'état actuel de l'interception. | Aucun. |
| `ogma_set_intercept_enabled` | Active ou désactive l'interception. | `request_enabled`, `response_enabled`, `websocket_enabled` |
| `ogma_list_intercept_queue` | Liste les éléments interceptés en attente. | Aucun. |
| `ogma_get_intercept_item` | Récupère un élément intercepté en attente. | **`id`** |
| `ogma_forward_intercept_item` | Transmet un élément intercepté, éventuellement modifié. | **`id`**, `method`, `path`, `headers`, `body`, `status_override` |
| `ogma_drop_intercept_item` | Abandonne un élément intercepté. | **`id`** |
| `ogma_intercept_and_modify` | Attend une requête ou une réponse interceptée en direct, applique des correctifs JSON, des remplacements par expressions régulières ou un remplacement complet du corps, puis la transmet. | **`direction`**, `host_pattern`, `path_pattern`, `wait_secs`, `json_patches`, `regex_replacements`, `body_b64`, `status_override`, `forward_unmatched` |

### Proxy, périmètre et réseau {#proxy-scope-and-network}

| Outil | Fonction | Paramètres |
| --- | --- | --- |
| `ogma_list_proxy_listeners` | Liste les services d'écoute du proxy. | Aucun. |
| `ogma_start_proxy_listener` | Démarre un service d'écoute du proxy. | **`listener_id`** |
| `ogma_stop_proxy_listener` | Arrête un service d'écoute du proxy. | **`listener_id`** |
| `ogma_list_scope_presets` | Liste les configurations prédéfinies de périmètre. | Aucun. |
| `ogma_create_scope_preset` | Enregistre une configuration prédéfinie de périmètre sans l'activer. Nécessite l'autorisation d'envoi. Chaque règle exige `pattern` et `include` ; le paramètre facultatif `rule_type` sélectionne une correspondance par hôte, CIDR, chemin ou expression régulière. Les règles de chemin utilisent `pattern` pour l'hôte et `path_pattern` pour le chemin. Activez séparément la configuration renvoyée avec `ogma_set_active_scope`. | **`name`**, **`rules`**, `httpql_expression` |
| `ogma_get_active_scope` | Récupère le périmètre actif. | Aucun. |
| `ogma_set_active_scope` | Définit le périmètre actif. | `preset_id` |
| `ogma_local_ips` | Liste les adresses IP locales utiles pour les services d'écoute et les interactions hors bande. | Aucun. |
| `ogma_get_tls_info` | Récupère les informations TLS d'une cible ou d'une connexion capturée. | **`host`**, `port` |

### Arborescence du site, Points d’accès et OAST {#sitemap-endpoints-and-oast}

| Outil | Fonction | Paramètres |
| --- | --- | --- |
| `ogma_get_sitemap` | Récupère l'arborescence du site capturée. | `host`, `show_api_only` |
| `ogma_get_sitemap_parameters` | Récupère les paramètres découverts pour un chemin de l'arborescence du site. | **`host`**, **`port`**, **`path`** |
| `ogma_list_extracted_endpoints` | Liste les points de terminaison extraits du trafic et du contenu frontend. | `limit`, `offset` |
| `ogma_discovery_start` | Lance en arrière-plan une tâche de découverte de contenu sur un hôte et un port inclus dans le périmètre ; renvoie un identifiant de tâche. | **`host`**, **`port`**, `tls`, `base_path`, `config` |
| `ogma_discovery_list` | Liste les tâches de découverte et leur progression dans le projet actif. | Aucun. |
| `ogma_discovery_get` | Récupère l'état d'une tâche de découverte et les résultats découverts. | **`job_id`** |
| `ogma_discovery_cancel` | Demande l'annulation d'une tâche de découverte en cours. | **`job_id`** |
| `ogma_import_openapi_spec` | Importe une spécification OpenAPI pour initialiser les points de terminaison et les structures de requête. | **`spec_content`**, `base_url`, `collection_name` |
| `ogma_get_oast_config` | Récupère la configuration du service d'écoute OAST. | Aucun. |
| `ogma_get_oast_reachability` | Indique si l'hôte de retour OAST configuré est accessible depuis une cible, avec les raisons d'une éventuelle inaccessibilité et les étapes pour y remédier. Vérifiez-le avant de vous fier à une charge utile aveugle : un hôte de retour inaccessible produit un faux négatif interprété comme une absence de vulnérabilité. | Aucun. |
| `ogma_list_oast_interactions` | Liste les interactions OAST. Chaque filtre est appliqué par le backend avant la pagination : le total compte donc toutes les correspondances, et non la longueur de la page, et restreindre la recherche à un libellé de jeton ou à une adresse source ne masque jamais une interaction correspondante plus loin dans le flux. `token_label` est le point d'injection qui portait le jeton : nom d'un paramètre de requête, nom d'un en-tête ou `body`. Les libellés sont conservés en mémoire avec leurs jetons ; un libellé dont le jeton a été retiré de la mémoire en raison de son ancienneté ne correspond donc à rien, plutôt qu'à des lignes périmées. | `limit`, `offset`, `token_id`, `token_label`, `protocol`, `source_ip`, `since` |

### Annotation de l'historique {#history-annotation}

| Outil | Fonction | Paramètres |
| --- | --- | --- |
| `ogma_set_entry_color` | Définit la couleur d'une entrée d'historique. | **`entry_id`**, **`color`** |
| `ogma_add_entry_tag` | Ajoute une étiquette à une entrée d'historique. | **`entry_id`**, **`tag`** |
| `ogma_remove_entry_tag` | Retire une étiquette d'une entrée d'historique. | **`entry_id`**, **`tag`** |

### Contrôle du navigateur {#browser-control}

Pour choisir entre instantanés, sélecteurs et captures d'écran, voir le [Guide du navigateur](../guide/mcp-browser.md). Ne supposez pas que tous les outils du navigateur acceptent `tab_id` ou `element_ref` ; utilisez uniquement les paramètres listés pour l'outil concerné.

| Outil | Fonction | Paramètres |
| --- | --- | --- |
| `ogma_browser_launch` | Lance le navigateur Ogma. | `proxy_port` |
| `ogma_browser_navigate` | Fait naviguer le navigateur vers une URL. | **`url`**, `tab_id`, `wait_for_load`, `timeout_ms`, `result_detail` |
| `ogma_browser_get_dom` | Navigue et renvoie le DOM rendu ainsi que les résultats facultatifs de sélecteurs après l'exécution du JavaScript. | **`url`**, `wait_secs`, `selectors`, `js_eval`, `include_full_html` |
| `ogma_browser_screenshot` | Capture l'état de la page du navigateur. | `tab_id`, `result_detail` |
| `ogma_browser_execute_js` | Exécute du JavaScript dans le navigateur. | **`script`**, `tab_id` |
| `ogma_browser_get_source` | Récupère le code source DOM de la page actuelle. | `tab_id`, `format`, `max_chars` |
| `ogma_browser_get_cookies` | Récupère les cookies du navigateur. | `tab_id` |
| `ogma_browser_set_cookie` | Définit un cookie du navigateur. | **`name`**, **`value`**, `domain`, `path`, `http_only`, `secure` |
| `ogma_browser_new_tab` | Ouvre un nouvel onglet du navigateur. | `url` |
| `ogma_browser_close_tab` | Ferme un onglet du navigateur. | `tab_id` |
| `ogma_browser_get_tabs` | Liste les onglets du navigateur. | `result_detail` |
| `ogma_browser_click` | Clique sur un `element_ref` issu d'un instantané ou sur des coordonnées `x` et `y` explicites. | `element_ref`, `snapshot_id`, `x`, `y`, `button`, `click_count`, `modifiers`, `offset_x`, `offset_y`, `force`, `timeout_ms`, `tab_id`, `expect`, `observation`, `result_detail` |
| `ogma_browser_type_text` | Saisit du texte dans le navigateur. | **`text`**, `tab_id`, `snapshot_id` |
| `ogma_browser_fill_input` | Renseigne un champ avec exactement un `selector` CSS ou un `element_ref` d'instantané ; une valeur vide l'efface. Ne soumet pas le formulaire. | **`selector`**, `value`, `tab_id`, **`element_ref`**, `snapshot_id`, `expect`, `observation`, `result_detail` |
| `ogma_browser_fill_form` | Remplace le texte de plusieurs champs, zones de texte ou éléments contenteditable en un appel, dans l'ordre fourni ; chaque champ utilise exactement un `element_ref` ou un `selector`, ainsi qu'une `value`. S'arrête au premier échec et ne soumet pas le formulaire. | **`fields`**, `snapshot_id`, `tab_id`, `expect`, `observation`, `result_detail` |
| `ogma_browser_click_selector` | Clique sur un élément à partir d'un sélecteur. | **`selector`**, `tab_id`, `expect`, `observation`, `result_detail` |
| `ogma_browser_submit_form` | Soumet un formulaire. | `selector`, `tab_id`, `expect`, `observation`, `result_detail` |
| `ogma_browser_get_page_links` | Extrait les liens de la page actuelle. | `tab_id` |
| `ogma_browser_get_page_forms` | Extrait les formulaires de la page actuelle. Définissez `include_templates` à `true` (par défaut `false`) pour ajouter l'URL d'action absolue, la méthode, le type de contenu effectif, les contrôles effectivement soumis avec leurs valeurs actuelles, les contrôles de soumission et les `token_candidates` ressemblant à des jetons CSRF de chaque formulaire. Les formulaires multipart renvoient vers `ogma_multipart_upload` au lieu de produire un corps synthétisé. Nécessite l'autorisation `send_requests`. | `tab_id`, `include_templates` |
| `ogma_browser_form_to_replay` | Crée une session Rejeu à partir d'un formulaire de la page active en lisant à cet instant les valeurs actuelles des champs et les cookies du navigateur, avec des en-têtes Origin et Referer issus de la page. N'envoie pas la requête. | **`form_selector`**, `tab_id`, `name` |
| `ogma_browser_scroll` | Fait défiler la page actuelle. | `selector`, `x`, `y`, `tab_id` |
| `ogma_browser_wait_for_selector` | Attend la présence d'un élément correspondant au sélecteur. | **`selector`**, `timeout_ms`, `tab_id`, `snapshot_id` |
| `ogma_browser_get_network_log` | Récupère les événements réseau du navigateur. | `host`, `since_ms`, `limit` |
| `ogma_browser_go_back` | Revient en arrière dans l'historique du navigateur. | `tab_id`, `snapshot_id` |
| `ogma_browser_go_forward` | Avance dans l'historique du navigateur. | `tab_id`, `snapshot_id` |
| `ogma_browser_reload` | Recharge la page. | `tab_id`, `snapshot_id` |
| `ogma_browser_find_text` | Recherche du texte dans la page actuelle. | **`text`**, `tab_id`, `snapshot_id` |
| `ogma_browser_clear_data` | Efface les données du navigateur. | `types` |
| `ogma_crawl_site` | Explore une cible via le navigateur intégré dans le périmètre actif et renvoie des données de couverture. | **`start_url`**, `max_pages`, `max_depth`, `wait_ms`, `tab_id` |

### Éléments du navigateur et attentes {#browser-elements-and-waits}

| Outil | Fonction | Paramètres |
| --- | --- | --- |
| `ogma_browser_snapshot` | Lit une arborescence sémantique compacte de la page avec les références et l'état des éléments ; `result_detail: "full"` renvoie à la place l'enveloppe structurée avec les éléments dans `raw.elements`. Peut demander un delta par rapport à un instantané précédent. | `tab_id`, `previous_snapshot_id`, `changes_only`, `focus_ref`, `text`, `max_elements`, `max_text_length`, `include_hidden`, `max_depth`, `result_detail` |
| `ogma_browser_hover` | Survole un élément référencé et rapporte les menus ou infobulles nouvellement visibles. | **`element_ref`**, `snapshot_id`, `offset_x`, `offset_y`, `modifiers`, `timeout_ms`, `tab_id` |
| `ogma_browser_select_option` | Sélectionne des options de liste déroulante par valeur, libellé ou indice et rapporte les valeurs sélectionnées. | **`element_ref`**, `snapshot_id`, **`values`**, `match_mode`, `allow_first_match`, `timeout_ms`, `tab_id` |
| `ogma_browser_check` | Définit explicitement l'état d'une case à cocher ou d'un bouton radio au lieu de le basculer à l'aveugle. | **`element_ref`**, `snapshot_id`, `checked`, `timeout_ms`, `tab_id` |
| `ogma_browser_press_key` | Envoie une touche ou une combinaison de touches à la page ayant le focus ou à un élément référencé. | **`key`**, `element_ref`, `snapshot_id`, `modifiers`, `repeat`, `delay_ms`, `tab_id` |
| `ogma_browser_focus` | Donne le focus à un élément référencé et rapporte ses capacités de saisie. | **`element_ref`**, `snapshot_id`, `tab_id` |
| `ogma_browser_blur` | Retire le focus de l'élément qui le possède actuellement. | `tab_id`, `snapshot_id` |
| `ogma_browser_drag_and_drop` | Fait glisser un élément référencé sur un autre. | **`source_ref`**, **`target_ref`**, `snapshot_id`, `steps`, `tab_id` |
| `ogma_browser_scroll_to` | Fait défiler jusqu'à un élément ou une position de page, ou à l'intérieur d'un conteneur de défilement référencé. | `target`, `element_ref`, `snapshot_id`, `container_ref`, `direction`, `amount`, `behavior`, `timeout_ms`, `tab_id` |
| `ogma_browser_wait_for` | Attend une condition d'élément, de texte, d'URL, de navigation ou de dialogue, ou la stabilité de la page ; prend en charge une pause explicite lorsque nécessaire. | **`condition`**, `target`, `timeout_ms`, `stability_ms`, `tab_id`, `snapshot_id`, `result_detail` |
| `ogma_browser_handle_dialog` | Accepte ou ferme un dialogue JavaScript, avec un texte d'invite facultatif et des vérifications du dialogue attendu. | **`action`**, `prompt_text`, `expected_type`, `expected_message`, `tab_id`, `snapshot_id` |
| `ogma_browser_dialog_status` | Rapporte tout dialogue JavaScript en attente sans le fermer. | Aucun. |

### Fichiers du navigateur, fenêtres contextuelles et téléchargements {#browser-files-popups-and-downloads}

| Outil | Fonction | Paramètres |
| --- | --- | --- |
| `ogma_list_hosted_files` | Liste les fichiers hébergés du projet actif et leurs identifiants pour les téléversements et l'inspection d'artefacts. | `limit`, `offset` |
| `ogma_artifact_read_range` | Lit une plage d'octets limitée d'un fichier hébergé au lieu de renvoyer le fichier entier. | **`artifact_id`**, `offset`, `length` |
| `ogma_artifact_search` | Recherche du texte littéral dans une plage limitée d'un fichier hébergé UTF-8 et renvoie les positions en octets des correspondances. | **`artifact_id`**, **`query`**, `offset`, `max_bytes`, `max_matches` |
| `ogma_browser_file_upload` | Renseigne un champ de fichier à partir d'identifiants de fichiers déjà hébergés dans Ogma, et non de chemins arbitraires dans le système de fichiers du client. | **`element_ref`**, `snapshot_id`, **`artifact_ids`**, `tab_id` |
| `ogma_browser_wait_for_popup` | Arme la détection de fenêtres contextuelles avant une action, attend une fenêtre contextuelle ou vérifie l'état de la détection. | **`action`**, `timeout_ms`, `switch_to_new_tab` |
| `ogma_browser_download_wait` | Détecte un téléchargement du navigateur en cours ou terminé. Examinez son identifiant et son état ; sa détection n'implique ni qu'il est terminé ni qu'il s'agit du téléchargement le plus récent. | `timeout_ms` |
| `ogma_browser_download_get` | Examine un téléchargement et enregistre le contenu terminé comme artefact lorsqu'il est disponible. | **`download_id`** |
| `ogma_browser_download_status` | Liste les téléchargements du navigateur et leur progression ou état actuel. | Aucun. |

### Identités, stockage et autorisations du navigateur {#browser-identities-storage-and-permissions}

Les outils d'autorisation du navigateur ci-dessous contrôlent les permissions des sites web, telles que la caméra ou la géolocalisation. Ils ne modifient pas les autorisations des outils du serveur MCP.

| Outil | Fonction | Paramètres |
| --- | --- | --- |
| `ogma_browser_context_create` | Crée une identité de navigateur isolée et un onglet initial ; renvoie `context_id` et `tab_id`. | `label`, `auth_profile_id`, `initial_url`, `retain_on_close` |
| `ogma_browser_context_clone` | Crée un contexte vierge ou copie les cookies du contexte source avec `clone_mode: authenticated` ; il ne s'agit pas d'un clonage complet du stockage. | **`context_id`**, `clone_mode`, `label` |
| `ogma_browser_context_close` | Ferme un contexte et ses onglets en effaçant le stockage, sauf si sa conservation a été demandée lors de la création. | **`context_id`** |
| `ogma_browser_context_list` | Liste les contextes de navigateur et leur état. | Aucun. |
| `ogma_browser_auth_state_capture` | Capture les cookies et le stockage web comme état d'authentification nommé, en mémoire ; renvoie des métadonnées expurgées. | **`name`**, `tab_id`, `context_id`, `role`, `url` |
| `ogma_browser_auth_state_apply` | Restaure un état d'authentification capturé ; les métadonnées d'expiration ne prouvent pas que le serveur accepte la session. | **`auth_state_id`**, `tab_id`, `context_id`, `url` |
| `ogma_browser_auth_state_list` | Liste les états d'authentification capturés sans les valeurs secrètes complètes. | Aucun. |
| `ogma_browser_auth_state_delete` | Supprime un état d'authentification capturé. | **`auth_state_id`** |
| `ogma_browser_storage_list` | Liste les cookies et les entrées du stockage web avec des aperçus raccourcis des valeurs. | `origin`, `storage_type` |
| `ogma_browser_storage_get` | Examine un cookie ou une clé de stockage avec un aperçu raccourci de sa valeur. | **`storage_type`**, **`key`**, `origin` |
| `ogma_browser_storage_set` | Écrit une valeur de cookie ou de stockage ; accepte une référence Ogma `env:VARIABLE_NAME`. | **`storage_type`**, **`key`**, **`value`**, `origin`, `domain`, `path`, `http_only`, `secure`, `expires` |
| `ogma_browser_storage_delete` | Supprime un cookie ou une clé de stockage web. | **`storage_type`**, **`key`**, `origin` |
| `ogma_browser_permissions_set` | Accorde, refuse ou réinitialise les permissions de site web spécifiées pour une origine. | **`origin`**, **`permissions`**, `setting`, `context_id` |
| `ogma_browser_permissions_reset` | Efface les dérogations aux permissions du navigateur. | `context_id` |
| `ogma_browser_permissions_get` | Interroge l'état des permissions de site web pour une origine. | **`origin`**, `permissions` |

### Diagnostics du navigateur, preuves et reprise {#browser-diagnostics-evidence-and-recovery}

| Outil | Fonction | Paramètres |
| --- | --- | --- |
| `ogma_browser_network_delta` | Récupère un nombre limité d'entrées réseau après un curseur en conservant les URL complètes, les temps, les erreurs et les identifiants Historique HTTP lorsqu'ils sont disponibles. | `since_entry_id`, `resource_types`, `status_filter`, `failed_only`, `max_entries` |
| `ogma_browser_console_delta` | Récupère les nouvelles entrées de console, avec l'URL source, la ligne et la colonne lorsque le navigateur les fournit. | `since_entry_id`, `levels`, `max_entries` |
| `ogma_browser_action_correlation` | Récupère le trafic et les événements associés à la fenêtre temporelle d'une action, ou liste les actions récentes. La concordance temporelle seule ne prouve pas un lien de causalité. | `browser_action_id`, `limit` |
| `ogma_browser_snapshot_save` | Archive l'instantané actuel pour une comparaison ultérieure ; l'archive conserve jusqu'à 20 instantanés. | `label` |
| `ogma_browser_page_state_compare` | Compare deux instantanés archivés et rapporte les différences d'éléments et d'état, en ignorant éventuellement les valeurs volatiles et les rôles. | **`snapshot_id_a`**, **`snapshot_id_b`**, `ignore_volatile`, `ignore_roles` |
| `ogma_browser_trace_start` | Démarre une trace d'actions légère ; `detailed` ajoute des références de console et de réseau. | `level`, `label`, `context_id` |
| `ogma_browser_trace_stop` | Arrête une trace et conserve ses événements en mémoire. | **`trace_id`** |
| `ogma_browser_trace_export` | Enregistre une trace arrêtée comme artefact de fichier JSON hébergé dans le projet actif. | **`trace_id`** |
| `ogma_browser_trace_list` | Liste les traces et leur état d'enregistrement ou d'export. | Aucun. |
| `ogma_browser_trace_note` | Ajoute une note à toutes les traces en cours d'enregistrement. | **`note`** |
| `ogma_browser_human_takeover_start` | Suspend les actions de navigateur de l'agent pour un point de contrôle manuel, avec un délai limité. | `reason`, `context_id`, `tab_id`, `timeout_ms` |
| `ogma_browser_human_takeover_complete` | Rend le contrôle après une interaction manuelle et actualise l'instantané de la page. | **`takeover_id`** |
| `ogma_browser_human_takeover_status` | Vérifie si le contrôle manuel est actif et indique le temps restant. | Aucun. |
| `ogma_browser_health` | Rapporte la santé de la passerelle de débogage et les informations récentes de plantage ou de déconnexion. | Aucun. |
| `ogma_browser_recover` | Tente de rétablir la passerelle en préservant les preuves par défaut ; peut signaler `relaunch_required`. | `preserve_evidence` |

### Tests d'authentification et d'autorisation {#authentication-and-authorization-testing}

| Outil | Fonction | Paramètres |
| --- | --- | --- |
| `ogma_auth_capture_profile` | Capture les cookies, le stockage, les jetons d'authentification détectés et les candidats CSRF du navigateur intégré. | **`name`**, `role`, `url`, `tab_id`, `wait_ms` |
| `ogma_auth_list_profiles` | Liste les profils d'authentification capturés avec des résumés des valeurs secrètes. | Aucun. |
| `ogma_auth_apply_profile` | Applique un profil d'authentification capturé au navigateur intégré pour changer de rôle ou de compte. | **`profile_id`**, `url`, `tab_id`, `wait_ms` |
| `ogma_auth_refresh_csrf` | Actualise les candidats de jetons CSRF à partir de la page actuelle, des cookies, du stockage, des balises meta et des champs masqués. | `profile_id`, `url`, `tab_id`, `wait_ms` |
| `ogma_login_replay_auto` | Détecte automatiquement un formulaire de connexion, soumet les identifiants dans le navigateur intégré et capture un profil d'authentification. | **`login_url`**, **`username`**, **`password`**, **`profile_name`**, `role`, `tab_id`, `wait_ms` |
| `ogma_authz_matrix_test` | Rejoue une requête capturée avec plusieurs profils d'authentification pour comparer les résultats des contrôles d'accès. | **`request_id`**, **`profile_ids`**, `mutations`, `entry_id` |

### Parcours de connexion réutilisables {#reusable-login-journeys}

Contrairement aux profils d'authentification en mémoire, les parcours de connexion sont persistants et propres au projet. Les identifiants de connexion référencent des identifiants de variables d'environnement Ogma. Toutes les vérifications configurées doivent réussir ; la seule soumission d'un formulaire de connexion ne constitue pas une authentification réussie.

| Outil | Fonction | Paramètres |
| --- | --- | --- |
| `ogma_auth_journey_record` | Enregistre les étapes de connexion, les références d'identifiants, les vérifications et les points de contrôle MFA manuels facultatifs. Cela définit un parcours ; cela n'enregistre pas automatiquement des clics arbitraires. | **`name`**, `role`, **`login_url`**, **`username_env_var_id`**, **`password_env_var_id`**, `username_selectors`, `password_selectors`, `submit_selectors`, `steps`, **`verification`**, `mfa`, `mfa_reason`, `mfa_timeout_ms` |
| `ogma_auth_journey_list` | Liste les parcours de connexion enregistrés dans le projet actif en masquant les secrets de session. | Aucun. |
| `ogma_auth_journey_replay` | Exécute un parcours de connexion enregistré, vérifie l'authentification et sauvegarde la session actualisée ; s'interrompt pour une MFA manuelle lorsque celle-ci est configurée. | **`journey_id`**, `tab_id` |
| `ogma_auth_journey_verify` | Vérifie l'URL, le DOM, les cookies et une requête de vérification facultative par rapport à la session actuelle. | **`journey_id`**, `tab_id` |
| `ogma_auth_journey_ensure` | Vérifie la session actuelle, tente de restaurer l'état enregistré et ne rejoue la connexion que si cela reste nécessaire. | **`journey_id`**, `tab_id` |
| `ogma_auth_journey_resume` | Poursuit un parcours après son point de contrôle manuel et vérifie la session obtenue. | **`journey_id`**, **`takeover_id`**, `tab_id` |

### Utilitaires et analyse {#utilities-and-analysis}

| Outil | Fonction | Paramètres |
| --- | --- | --- |
| `ogma_fetch_sourcemap` | Récupère et examine une carte de correspondance du code source JavaScript (source map). | **`url`**, `base_url` |
| `ogma_proto_decode` | Décode les charges utiles protobuf avec les schémas configurés. | **`data_b64`**, `content_type` |
| `ogma_decode_jwt` | Décode les en-têtes et les déclarations (claims) JWT. | **`token`** |
| `ogma_decode_response` | Décode, décompresse ou transforme les corps de réponse avec des opérations ordonnées, notamment Base64, gzip, deflate, brotli, URL, entités HTML et hexadécimal. | **`input`**, `input_is_b64`, **`operations`**, `max_output_bytes` |
| `ogma_search_js_secrets` | Recherche des secrets et points de terminaison exposés dans les réponses JavaScript. | `host`, `patterns` |
| `ogma_compare_responses` | Compare deux réponses. | **`entry_id_a`**, **`entry_id_b`**, `mode` |
| `ogma_bytes_transform` | Effectue des transformations d'octets, notamment l'encodage, le décodage, le XOR, le hachage et l'extraction. | **`operation`**, **`data`**, `key`, `output_encoding`, `offset`, `length`, `min_len` |
| `ogma_wasm_inspect` | Examine un module WebAssembly. | **`wasm_b64`**, `data_encoding` |
| `ogma_fingerprint_target` | Identifie les technologies de la cible à partir du trafic et des réponses capturés. | `host`, `entry_limit` |
| `ogma_sign_request` | Calcule les en-têtes de signature HMAC-SHA256 des requêtes pour les applications utilisant des mécanismes de signature côté client. | **`key`**, **`method`**, **`path`**, `params` |
| `ogma_find_in_response` | Récupère jusqu'à 10 URL et recherche une expression régulière dans les corps de réponse avec un contexte compact. | **`urls`**, **`pattern`**, `headers`, `context_chars`, `max_matches_per_url`, `case_insensitive`, `timeout_secs` |
| `ogma_think` | Consigne un raisonnement structuré ou un plan textuel dans la session MCP. | **`thought`** |
| `ogma_explain_capabilities` | Renvoie le résumé des capacités du serveur MCP. | Aucun. |

### Outils d'aide aux sondes actives {#active-probe-helpers}

| Outil | Fonction | Paramètres |
| --- | --- | --- |
| `ogma_run_active_probe_workflow` | Exécute une sonde limitée, propre à une vulnérabilité, sur une requête capturée. Les modules comprennent IDOR/BOLA, CORS, SSRF OAST, XSS réfléchi ou stocké, SQLi temporelle ou fondée sur les erreurs, traversée de répertoires, SSTI, contournement des contrôles de téléversement, introspection et autorisation GraphQL, manipulation de JWT et vérifications des limites de débit. | **`probe`**, **`request_id`**, `entry_id`, `target_param`, `profile_ids`, `values`, `origins`, `max_cases` |
| `ogma_test_race` | Envoie une même requête simultanément et rapporte le code de statut le plus fréquent, les réponses qui s'en écartent et un verdict. Utilisez-le pour les opérations à usage unique : plusieurs réponses de succès à une opération qui ne doit réussir qu'une fois montrent qu'elle n'est pas atomique. Fournissez `request_id` pour une entrée capturée, ou `host` et `port` en précisant explicitement le reste de la requête. Activez `http2` pour envoyer chaque requête comme flux simultané sur une seule connexion (single-packet), variante qui exploite les fenêtres temporelles étroites lorsque la cible utilise HTTP/2 ; par défaut, une connexion est ouverte par requête. Un écart ne renseigne que sur la gestion de la concurrence, et un lot uniforme ne prouve pas l'atomicité ; confirmez donc en examinant l'état modifié par l'opération. | `request_id`, `entry_id`, `method`, `host`, `port`, `tls`, `path`, `query`, `params`, `headers`, `body_b64`, `concurrency`, `stagger_ms`, `http2` |
| `ogma_test_smuggling` | Envoie des sondes de désynchronisation CL.TE et TE.CL sur TCP brut et rapporte les résultats des sondes, les candidats et un verdict. Les en-têtes fournis dans `headers` accompagnent uniquement la requête de sonde ; la requête suivante qui mesure la désynchronisation est toujours envoyée sans eux. La sonde est heuristique et se trompe souvent dans les deux sens : un frontal qui ferme la connexion après la première requête ou qui rejette le cadrage contradictoire avec un code 400 donne le même résultat de sonde qu'un frontal vulnérable, et un résultat négatif ne prouve pas l'absence de risque. Confirmez avant de rapporter : rejouez les octets de la sonde avec `ogma_http_request` en mode brut, en les fournissant dans `raw_request_base64` avec `max_responses` défini à 2 pour lire la réponse que les octets n'ont pas sollicitée, puis envoyez une requête ordinaire avec `followup_raw_request_base64` sur la même connexion et comparez les deux statuts. HTTP/1.x uniquement. | **`host`**, **`port`**, `tls`, `path`, `timeout_ms`, `headers` |
| `ogma_test_hpp` | Envoie des variantes de pollution de paramètres HTTP pour les paramètres nommés, puis indique quelle variante a modifié le statut ou le corps de la réponse, avec un verdict. Utilisez-le lorsqu'un paramètre est validé dans un composant et consommé dans un autre : un nom dupliqué peut être interprété différemment par chacun. Une réponse modifiée montre que les paramètres dupliqués sont traités différemment ; elle ne prouve pas à elle seule qu'un contrôle a été contourné. `headers` est envoyé avec chaque requête, y compris celle de référence ; un en-tête Cookie ou Authorization permet donc de sonder un point de terminaison nécessitant des identifiants. Sans en-têtes, les requêtes ne contiennent ni cookies ni authentification : une variante qui ne change rien sur un point de terminaison protégé par une connexion ne prouve rien. | **`host`**, **`port`**, **`params`**, `tls`, `path`, `base_value`, `test_value`, `timeout_ms`, `headers` |
| `ogma_list_nuclei_templates` | Liste les modèles du scanner fournis avec Ogma, avec leur gravité et la signification d'une correspondance. Lisez cette liste avant `ogma_run_nuclei` pour choisir un modèle par son nom. | Aucun. |
| `ogma_run_nuclei` | Exécute un modèle sur une URL cible et rapporte chaque correspondance. Ne crée aucun constat. Fournissez `template` pour un modèle intégré ou `template_yaml` pour votre propre document, mais pas les deux. L'analyseur ne prend en charge qu'un sous-ensemble de nuclei : critères de correspondance de statut, de mot et d'expression régulière, `matchers-condition` et extracteurs par expression régulière. Les types de critères hors de ce sous-ensemble, dont les expressions DSL, sont ignorés plutôt qu'évalués, et l'outil n'exécute pas tous les modèles qu'une installation complète de nuclei accepterait. Les modèles vérifient les surfaces d'exposition et de mauvaise configuration invisibles au scanner passif, telles qu'un `.env`, un `.git/config`, un point de terminaison actuator ou une page d'état du serveur exposés. | **`target`**, `template`, `template_yaml` |
| `ogma_record_test_attempt` | Consigne le test d'un point de terminaison, d'un paramètre ou d'un vecteur et son résultat, afin qu'une session ultérieure puisse distinguer une piste épuisée d'un point non testé. Seul `no_signal` clôt une piste ; `transport_error` signifie que la sonde n'a jamais atteint la cible et ne prouve donc rien sur le vecteur. | **`host`**, **`port`**, **`path`**, **`vector`**, **`outcome`**, **`reason`**, `parameter`, `payload_label`, `evidence_entry_id` |
| `ogma_list_test_attempts` | Liste les tentatives de test enregistrées, de la plus récente à la plus ancienne, et les regroupe par hôte, port, chemin, paramètre et vecteur, en indiquant la tentative déterminante de chaque point, son nombre de tentatives et son éventuel épuisement. Un point n'est épuisé que lorsque son résultat déterminant est `no_signal` ; un `transport_error` ultérieur ne lève pas cet état. | `host`, `port`, `path`, `vector`, `limit` |

### Tests WebSocket directs {#direct-websocket-testing}

| Outil | Fonction | Paramètres |
| --- | --- | --- |
| `ogma_websocket_connect` | Se connecte à une URL `ws://` ou `wss://`, envoie des messages et renvoie une transcription. | **`url`**, **`messages`**, `headers`, `timeout_secs` |
| `ogma_ws_capture_history` | Enregistre une transcription WebSocket issue d'`ogma_websocket_connect` comme historique Ogma structuré pour son examen et la liaison des preuves. | **`url`**, **`transcript`**, `label` |

### Rechercher et remplacer {#match-and-replace}

| Outil | Fonction | Paramètres |
| --- | --- | --- |
| `ogma_list_match_replace_rules` | Liste les règles Rechercher et remplacer. | Aucun. |
| `ogma_create_match_replace_rule` | Crée une règle Rechercher et remplacer ; les opérations de workflow nécessitent workflow\_id. | **`name`**, `enabled`, **`direction`**, **`operation`**, **`match_value`**, `match_mode`, `replace_value`, `filter_method`, `filter_host`, `filter_path`, `filter_httpql`, `position`, `workflow_id` |
| `ogma_toggle_match_replace_rule` | Active ou désactive une règle Rechercher et remplacer. | **`rule_id`**, **`enabled`** |
| `ogma_delete_match_replace_rule` | Supprime une règle Rechercher et remplacer. | **`rule_id`** |

### Variables d'environnement {#environment-variables}

| Outil | Fonction | Paramètres |
| --- | --- | --- |
| `ogma_list_env_vars` | Liste les noms et métadonnées des variables d'environnement. | Aucun. |
| `ogma_set_env_var` | Crée ou met à jour une variable d'environnement. | **`name`**, **`value`**, `scope`, `is_secret` |
| `ogma_get_env_var_value` | Lit la valeur d'une variable d'environnement lorsque cela est autorisé. | **`name`** |

### Projets, notes, tâches et session {#projects-notes-todos-and-session}

Un changement de projet affecte le projet actif dans Ogma, et pas seulement l'agent demandeur. Coordonnez-vous avec les autres clients. Les outils de notes et de tâches ci-dessous constituent un **bloc-notes en mémoire de la session MCP**, et non la page Notes persistante de l'application. Conservez le rapport de session avant de vous déconnecter ou de redémarrer MCP.

| Outil | Fonction | Paramètres |
| --- | --- | --- |
| `ogma_list_projects` | Liste les projets. | Aucun. |
| `ogma_switch_project` | Change le projet actif. | `project_id`, `project_name` |
| `ogma_start_pentest_session` | Crée un plan d'audit structuré et, par défaut, une note ou liste de contrôle locale à la session pour la cible. Ne lance pas automatiquement une analyse complète. | **`target_url`**, `objective`, `mode`, `create_scratchpad` |
| `ogma_get_coverage_status` | Résume l'avancement de la liste de contrôle de la session actuelle et la couverture restante ; ne prouve pas que les tests sont complets. | Aucun. |
| `ogma_recommend_skills` | Suggère des instructions de compétences intégrées à partir des technologies observées, des chemins, des en-têtes et d'autres éléments de contexte fournis. | `observations`, `paths`, `content_types`, `headers`, `technologies`, `response_snippets`, `notes` |
| `ogma_note_create` | Crée une note. | **`title`**, **`content`**, `category` |
| `ogma_note_list` | Liste les notes. | `category` |
| `ogma_note_get` | Récupère une note. | **`id`** |
| `ogma_note_update` | Met à jour une note. | **`id`**, `title`, `content`, `category` |
| `ogma_note_delete` | Supprime une note. | **`id`** |
| `ogma_todo_create` | Crée une tâche. | **`task`**, `priority` |
| `ogma_todo_list` | Liste les tâches. | `status`, `priority` |
| `ogma_todo_update` | Met à jour une tâche. | **`id`**, `task`, `priority`, `status` |
| `ogma_todo_mark_done` | Marque une tâche comme terminée. | **`id`** |
| `ogma_todo_delete` | Supprime une tâche. | **`id`** |
| `ogma_finish_session` | Finalise la session MCP avec un résumé, une méthodologie et des recommandations. | **`summary`**, **`methodology`**, **`recommendations`** |
| `ogma_get_session_report` | Récupère le rapport de la session MCP actuelle. | Aucun. |

## Relation avec l'IA de l'espace de travail (Workspace AI) {#relationship-to-workspace-ai}

Le serveur MCP est un serveur de protocole utilisé par des outils externes. L'IA de l'espace de travail, intégrée à l'application, est une fonctionnalité Vue exécutée dans le navigateur qui appelle directement les fournisseurs d'IA configurés et expose sa propre liste d'outils frontend. Voir [IA de l'espace de travail](../guide/workspace-ai.md).