Table of Contents

🇬🇧 English version

Intégration MCP (Model Context Protocol)

Statut : expérimental ([Experimental("ORKEXP004")] sur chaque type MCP — voir APIs expérimentales). Bi-génération : client et serveur parlent les deux lignées du protocole. Code : src/core/Orkeon.Infrastructure/MCP/.

L'intégration MCP fonctionne dans les deux sens :

  • Client — McpClient parle JSON-RPC Ă  un serveur MCP externe ; McpToolProvider se connecte Ă  un nombre quelconque de serveurs, liste leurs outils et enregistre chacun dans l'IToolRegistry d'Orkeon sous forme d'McpToolAdapter (IBaseTool). Le ToolAccess de l'adaptateur ne vient des annotations MCP de l'outil que pour un serveur auquel l'opĂ©rateur fait confiance (MCP:Servers:<name>:TrustAnnotations = true) : Read pour readOnlyHint: true, Execute pour des annotations qui ne le portent pas. Un serveur est non fiable par dĂ©faut : n'importe quel serveur peut Ă©tiqueter en lecture seule un outil destructeur, que le mode plan laisserait alors passer ; ses outils restent donc Unspecified (la classification fail-closed de la permission gate) quoi que disent leurs indications — comme ceux d'un serveur qui n'envoie aucune annotation. DisconnectServerAsync les dĂ©senregistre. Un agent de crew liste un tel outil par son nom, comme n'importe quel autre — voir Outils MCP et crews.
  • Serveur — McpServer expose les outils de l'IToolRegistry d'Orkeon aux clients MCP externes (tools/list / tools/call, avec conversion ToolSchema → JSON Schema), sur stdio (RunStdioAsync) ou par traitement de requĂŞtes individuelles (ProcessRequestAsync). Chaque tools/call franchit le point d'invocation que franchissent les appels d'un agent de crew — garde, troncature, assainisseur de rĂ©sultat, audit. Seule la capacitĂ© outils est annoncĂ©e, plus des resources en lecture seule quand /output est exposĂ© (opt-in), plus les prompts et les outils de crew quand --crew nomme des crews. La boucle stdio traite les requĂŞtes en concurrence et honore notifications/cancelled. orkeon mcp serve le sert sur stdio — voir Servir les outils avec orkeon mcp serve.

Négociation de version : deux lignées de protocole

McpProtocol déclare ce que les deux côtés parlent :

  • LignĂ©e moderne, sans Ă©tat — ModernVersion = "2026-07-28". Pas de handshake : chaque requĂŞte porte _meta (io.modelcontextprotocol/protocolVersion, clientInfo, clientCapabilities) ; la dĂ©couverte des capacitĂ©s est la mĂ©thode server/discover.
  • LignĂ©e legacy Ă  initialize — SupportedLegacyVersions = ["2025-11-25", "2025-06-18", "2024-11-05"] : handshake initialize classique suivi du notifications/initialized obligatoire. 2025-03-26 est dĂ©libĂ©rĂ©ment exclue : c'est la seule rĂ©vision qui impose le batching JSON-RPC, que cette implĂ©mentation ne parle pas.

Client (McpClient.ConnectAsync)

  1. Sonde avec server/discover (en déclarant 2026-07-28 dans _meta).
  2. Succès avec supportedVersions → serveur moderne ; adoption de la révision la plus récente supportée des deux côtés. Un succès sans supportedVersions est un serveur legacy répondant avec indulgence à une méthode inconnue → repli sur initialize.
  3. Erreur -32022 UnsupportedProtocolVersionError → serveur moderne quand même ; lecture de sa liste supportée dans les données de l'erreur, renégociation, nouvelle tentative de server/discover.
  4. Toute autre erreur → serveur legacy ; handshake initialize, qui négocie réellement (la révision choisie par le serveur est acceptée si le client la supporte) et se termine par notifications/initialized.

Sur une connexion moderne établie, chaque requête porte son _meta ; un -32022 en cours de route déclenche une renégociation + une nouvelle tentative avec une révision supportée des deux côtés (McpClient.SendAsync).

Ce que le client garde du schéma d'un outil distant

McpToolAdapter lit l'inputSchema d'un outil distant pour en faire le schéma montré au modèle d'un agent, entier et à toute profondeur. De chaque propriété il garde le type, la description, le default comme la valeur JSON qu'il est (null n'est pas un défaut), l'enum (chaque valeur scalaire telle quelle : une chaîne, un nombre, un booléen) ou un const (un enum d'une valeur), le format, les bornes (minimum, maximum, exclusiveMinimum, exclusiveMaximum — la forme booléenne du draft 04 aussi —, minLength, maxLength, pattern, minItems, maxItems), les items d'un tableau — un tableau de tableaux compris —, les properties et le required d'un objet, ses additionalProperties (le schéma des valeurs d'un dictionnaire, ou false) et les alternatives d'anyOf et de oneOf (montrées comme anyOf). La racine est lue comme tout autre schéma : un $ref, un allOf ou un anyOf / oneOf nullable qui tient lieu d'un objet donne les propriétés de cet objet ; de ses additionalProperties, la racine ne garde que false. Un $ref local (#/$defs/X, #/definitions/X, tout pointeur JSON dans le document, # la racine) est le schéma qu'il nomme, la description, le default et le format écrits à côté l'emportant sur ceux de la définition, l'enum et les bornes écrits à côté valant là où la définition n'en a pas. Un type écrit comme un tableau est lu comme son seul membre autre que "null" (["string", "null"], un paramètre nullable, est un string) ; un anyOf / oneOf dont la seule alternative hormis le schéma nul est X — l'Optional[X] de Pydantic — est X, comme un allOf d'un seul schéma X ; le schéma nul s'écrit {"type": "null"}, {"type": ["null"]}, {"const": null} ou {"enum": [null]}. Un allOf dont les membres sont tous des objets (leur $ref suivi), à côté d'un schéma qui est un objet ou ne nomme aucun type, est un seul objet : l'union de leurs propriétés (le premier qui en nomme une l'emporte), l'union de leurs required, et additionalProperties: false dès que l'un d'eux le dit. Une propriété qui a des properties sans type est un objet. Un tuple (items en tableau, ou prefixItems avec les items qui le suivent) est lu comme les alternatives de ses positions, et items: false comme maxItems. Restent perdus, entre autres : la position des éléments d'un tuple, un allOf dont un membre n'est pas un objet, une ancre (#nom) ou une référence à un autre document et une référence coupée sur un cycle (un arbre dont le nœud contient des nœuds), qui acceptent n'importe quelle valeur JSON, not, if / then / else, patternProperties, uniqueItems, multipleOf, dependentRequired, additionalItems, title, minProperties / maxProperties, propertyNames, contains, un membre d'enum qui est null ou n'est pas un scalaire, et ce qui se trouve à plus de 32 niveaux de profondeur (n'importe quelle valeur JSON). Une propriété à plusieurs types, ou sans aucun ({}), n'a pas de type : le modèle peut donner n'importe quelle valeur JSON. Un tableau dont les éléments ne sont pas connus — pas d'items, des éléments sans type unique — est montré avec items: {}, n'importe quelle valeur JSON : aucun tableau n'arrive à un fournisseur sans items, que certains refusent. Un outil dont l'inputSchema s'étend à plus de 4096 schémas, ou copie plus de 1 Mio de texte, coûterait la mémoire de l'hôte et le contexte du modèle : chaque usage d'un $ref est compté (une définition utilisée plusieurs fois compte à chaque fois, puisque le modèle la voit à chaque fois), et l'outil est écarté avec un avertissement écrit une fois par définition d'outil distincte, comme ci-dessous.

Aucun inputSchema ne fait échouer la connexion : une entrée de required ou la description d'une propriété qui n'est pas une chaîne est ignorée, un nombre qu'aucun double ne contient (1e400) est retiré d'un enum ou d'un default, et la liste est lue outil par outil : une entrée qui n'est pas un objet (null), un outil sans nom, ou un outil dont le name, la description ou les annotations ont le mauvais type JSON (un name qui est un nombre) est écarté à lui seul — les autres outils de son serveur sont enregistrés. L'avertissement nomme l'outil et le serveur tel que MCP:Servers le nomme, et il est écrit une fois pour cette entrée, pas à chaque lecture de la liste — pour un inputSchema illisible, une fois pour cette définition : un serveur qui la change est signalé de nouveau. Quand tools/list_changed apporte une telle entrée pour un outil qui était enregistré, l'outil quitte le registre. Un "tools": null ne liste aucun outil, pas plus qu'un result absent ou null. Une liste d'outils de la mauvaise forme — un tools qui n'est ni null ni un tableau, un result présent qui n'est pas un objet, un nextCursor qui n'est pas une chaîne — n'est pas une liste vide : elle échoue, avec un message qui nomme le serveur et le membre ; la connexion est donc signalée en échec, et un tools/list_changed qui apporte une telle réponse laisse en place les outils enregistrés. Un nom qu'un serveur liste deux fois, sur une page ou sur deux, est enregistré une fois, la première, et signalé une fois : ce n'est pas une collision, et l'état du serveur ne rejette rien ; les noms sont comparés comme le registre les compare, sans leur casse. prompts/list et resources/list sont lus entrée par entrée eux aussi : un prompt sans nom, une ressource sans uri, ou une entrée dont les membres ont le mauvais type JSON est écartée à elle seule avec un avertissement écrit une fois, un null parmi les arguments d'un prompt est retiré, et un prompts ou un resources à null ne liste rien. Un nom de prompt ou une uri de ressource listé deux fois est gardé une fois, le premier, et signalé une fois (prompts/get et resources/read nomment une entrée ; les noms sont comparés avec leur casse). Aucun registre ne suit ces deux listes : une liste de la mauvaise forme donne ce qui a pu être lu, avec un avertissement.

Les avertissements du client portent un nom d'événement qu'un filtre de journal peut viser : mcp.tool.unreadable (un outil écarté, son entrée ou son inputSchema), mcp.entry.unreadable (un prompt ou une ressource écarté), mcp.entry.duplicate (un outil, un prompt ou une ressource listé deux fois), mcp.listing.unreadable (un prompts/list ou un resources/list de la mauvaise forme) et mcp.tool.rejected (un nom qu'un autre outil détient).

Serveur (McpServer) — bi-génération sur un même endpoint

  • ImplĂ©mente server/discover (versions supportĂ©es, capacitĂ©s, indices de fraĂ®cheur ttlMs/cacheScope, identitĂ© du serveur dans le _meta du rĂ©sultat).
  • Une requĂŞte dĂ©clarant une version _meta non supportĂ©e est rejetĂ©e en -32022 avec le payload { supported, requested }, quelle que soit la mĂ©thode.
  • Le initialize legacy renvoie la rĂ©vision demandĂ©e quand elle est supportĂ©e, sinon la rĂ©vision legacy la plus rĂ©cente. ping reste servi pour les sessions legacy seulement (retirĂ© de la lignĂ©e moderne).
  • tools/list est renvoyĂ© en ordre dĂ©terministe (tri ordinal par nom — un SHOULD de 2026-07-28, pour des caches clients stables) avec les champs modernes resultType/ttlMs/cacheScope ; les clients legacy ignorent ces membres additifs.
  • Une notification valide — un message sans id — ne reçoit jamais de rĂ©ponse, pas plus qu'une rĂ©ponse (un result ou un error sans method, quel que soit le reste de son enveloppe : le serveur n'envoie aucune requĂŞte, il l'ignore). Une ligne qui est du JSON mais pas une requĂŞte valide reçoit -32600 Invalid Request, y compris une notification dont l'enveloppe est invalide (sa rĂ©ponse porte un id null) ; -32700 est rĂ©servĂ© au texte qui n'est pas du JSON. Sont refusĂ©s ainsi : une valeur qui n'est pas un objet (un scalaire, null, un tableau — le batching n'est pas parlĂ©, un lot reçoit donc une seule rĂ©ponse pour toute la ligne), un jsonrpc absent ou diffĂ©rent de "2.0", une method absente, vide ou qui n'est pas une chaĂ®ne, un id null ou qui n'est ni une chaĂ®ne ni un entier, un params qui n'est ni un objet ni un tableau (null vaut absence), et un id Ă  cĂ´tĂ© d'une mĂ©thode notifications/* (MCP l'interdit : le message reçoit une rĂ©ponse, il n'est pas exĂ©cutĂ©). La rĂ©ponse porte l'id quand il a pu ĂŞtre lu — une chaĂ®ne ou un entier —, null sinon. Une ligne de JSON valide imbriquĂ©e au-delĂ  de 64 niveaux est refusĂ©e de la mĂŞme façon, avec un id null : -32700 reste rĂ©servĂ© au texte qui n'est pas du JSON. ProcessRequestAsync donne Ă  un hĂ´te C# les mĂŞmes rĂ©ponses pour la requĂŞte qu'on lui remet, et seulement pour ce que cette requĂŞte contient encore : un hĂ´te qui dĂ©sĂ©rialise lui-mĂŞme le message en JsonRpcRequest perd un id null (le message est pris pour une notification) et un jsonrpc absent (il vaut "2.0" par dĂ©faut, le message est donc exĂ©cutĂ©), et une rĂ©ponse qu'il lui remet reçoit -32600 lĂ  oĂą la boucle stdio l'ignore.
  • Un message ne porte jamais de membre null : une rĂ©ponse contient result ou error, jamais les deux, et un membre optionnel sans valeur est absent — un client strict (les SDK MCP) refuse le message sinon. Le seul null est l'id de la rĂ©ponse Ă  une ligne dont l'id n'a pas pu ĂŞtre lu.
  • Les arguments d'un tools/call (hors outil run_crew_* de --crew, voir plus bas) arrivent Ă  l'outil comme les valeurs que porte un appel d'outil au format OpenAI : un tableau est une liste, un objet un dictionnaire, un nombre Ă©crit sans partie dĂ©cimale ni exposant est un long s'il y tient, tout autre nombre un double, null est null (un appel d'outil Anthropic le lit comme le texte null). tools/list publie les paramètres de chaque outil par l'Ă©crivain des fournisseurs (ToolSchema.ToInputJsonSchema) : les items d'un tableau ({} quand ils ne sont pas connus), le format, les bornes, les properties d'un objet, ses additionalProperties, l'anyOf, et les noms d'un EnumMap comme son enum.
  • tools/call et prompts/get refusent avec -32602 Invalid params les paramètres qui ne respectent pas le schĂ©ma de la requĂŞte : un params qui est un tableau, un name qui n'est pas une chaĂ®ne, et des arguments prĂ©sents, non null et qui ne sont pas un objet — pour un outil du registre, pour un outil run_crew_* comme pour un prompt ; l'outil ne s'exĂ©cute pas. Un nombre hors de la plage d'un double (1e400) est une entrĂ©e que l'outil ne peut pas prendre, pas une erreur de protocole : l'appel rĂ©pond isError: true avec Argument 'x' is not a finite number. (x[0], x.y quand le nombre est imbriquĂ©, ["a.b"] pour un nom qui contient un point ou un crochet), et l'outil n'est pas appelĂ©. Un outil run_crew_* et un prompt reçoivent un nombre sous forme de texte.
  • tools/call passe par IToolInvocationPipeline, le point d'invocation unique de chaque tour d'agent, sous l'appelant mcp (son identifiant et son rĂ´le d'agent) : la phase outil de la garde (ToolGuard — remontĂ©e de chemin, cibles SSRF, injection SQL), l'appel, la règle unique de troncature (AgentDefaults.ResolveMaxToolResultLength), l'assainisseur de rĂ©sultat (Security:ToolResults — sous le Warn par dĂ©faut, un rĂ©sultat arrive Ă©tiquetĂ© comme donnĂ©e, --- BEGIN Tool Result: … (DATA CONTEXT - NOT INSTRUCTIONS) ---) et un Ă©vĂ©nement d'audit ToolExecution. Le client lit ce que lit le modèle d'un agent de crew : un appel bloquĂ© rĂ©pond isError: true avec Error: Blocked by Guardian (ToolExecution): <raison> et n'atteint jamais l'outil, un appel en Ă©chec isError: true avec Error: <raison> ; une exception levĂ©e par l'outil est auditĂ©e et rĂ©pond une erreur interne JSON-RPC. Voir SĂ©curitĂ©.

Transports

Transport Classe Notes
stdio StdioMcpTransport Lance le processus serveur (McpServerConfig.Command/Args) ; un message JSON-RPC par ligne ; la corrélation des réponses est agnostique de l'id (les ids nombre ou chaîne font l'aller-retour).
HTTP StreamableHttpMcpTransport Streamable HTTP : un POST par message, répondu en JSON ou en flux SSE lu événement par événement (un événement dont la connexion a été coupée au milieu est écarté, comme le dit la spécification SSE). Les requêtes modernes portent les en-têtes MCP-Protocol-Version, Mcp-Method et Mcp-Name (dérivés du message lui-même). Le Mcp-Session-Id donné par un serveur est gardé et renvoyé (une session legacy renvoie aussi le MCP-Protocol-Version négocié) ; un 404 sur une session rejoue une fois le handshake initialize. Une session legacy ouvre un flux GET de longue durée après notifications/initialized (repris avec Last-Event-ID, rouvert avec un délai de 0,5 s doublé jusqu'à 30 s, ou le retry: du serveur) ; un serveur qui répond 405 n'est plus sollicité, et un serveur qui répond 404 après chaque nouvelle session est abandonné après 3 réinitialisations de suite, chacune après le délai. La session se termine par un DELETE à la libération du transport. Le transport HTTP+SSE de 2024-11-05 à endpoint séparé n'est pas supporté.

Activation

services.AddOrkeonMcp(configuration);         // le client — lit la section "MCP"
services.AddOrkeonMcpServer(configuration);   // le serveur, pour un hĂ´te qui sert ses outils

AddOrkeonMcp lie McpOptions (Enabled, true par défaut ; Servers — un dictionnaire de McpServerConfig indexé par identifiant de serveur : Transport Stdio (défaut) ou Sse, Command/Args/Env pour stdio, Url pour HTTP) et enregistre McpToolProvider en singleton. Il n'enregistre aucun serveur : c'est AddOrkeonMcpServer qui enregistre McpServer (+ McpServerOptions depuis MCP:Server : Name, Orkeon par défaut, Version, vide par défaut — la version de la release en cours d'exécution —, MaxConcurrency (4), ExposeOutput (faux), ResourcesPageSize (100) et MaxResourceBytes (1 Mio)), lequel sert l'IToolRegistry du conteneur et appelle chaque outil par son IToolInvocationPipeline — AddOrkeonInfrastructure() et AddOrkeonApplication() enregistrent les deux. Enregistrer n'est pas servir : l'hôte lance RunStdioAsync — ce que fait orkeon mcp serve — ou ProcessRequestAsync lui-même. Aucun réglage ne démarre le serveur : la section MCP ne porte aucune clé de ce genre, et chaque runner bâti sur RunnerHost refuse une clé inconnue au démarrage, serveurs déclarés ou non. Le serveur expose des outils, et /output comme ressources quand ExposeOutput est actif (ci-dessous) ; prompts/* répondent Method not found sauf si l'hôte donne au serveur un IMcpServerExtension (orkeon mcp serve --crew le fait), et aucune option ne prétend le contraire. La surcharge AddOrkeonInfrastructure(IConfiguration) appelle elle-même AddOrkeonMcp, jamais AddOrkeonMcpServer.

{
  "MCP": {
    "Enabled": true,
    "Servers": {
      "filesystem": {
        "Transport": "Stdio",
        "Command": "npx",
        "Args": [ "-y", "@modelcontextprotocol/server-filesystem", "/srv/data" ],
        "Env": { "NODE_ENV": "production" }
      },
      "search": {
        "Transport": "Sse",
        "Url": "https://mcp.example.com/mcp",
        "Auth": { "Type": "Bearer", "TokenEnv": "SEARCH_MCP_TOKEN" },
        "Headers": { "X-Tenant": "env:SEARCH_MCP_TENANT" },
        "Tools": { "Allow": [ "search", "fetch" ], "Deny": [ "fetch" ] },
        "CallTimeout": "00:00:30"
      }
    },
    "Server": { "Name": "Orkeon" }
  }
}

Le serveur et le client se présentent comme Orkeon, avec la version de la release qu'ils exécutent (celle qu'affiche orkeon --version), dans le handshake legacy (serverInfo, clientInfo) et dans le _meta des requêtes modernes et des réponses à server/discover et tools/list. MCP:Server:Version, quand il n'est pas blanc, remplace celle du serveur ; rien ne remplace celle du client.

Authentification, filtre et délai par serveur. Chaque MCP:Servers:<id> accepte :

  • Auth : Type vaut None (dĂ©faut), Bearer (Authorization: Bearer, le jeton lu dans la variable que nomme TokenEnv) ou Basic (UserEnv et PasswordEnv). Les variables sont lues Ă  chaque requĂŞte : un jeton renouvelĂ© ne demande aucun redĂ©marrage. Aucun identifiant n'est jamais Ă©crit dans les rĂ©glages.
  • Headers : en-tĂŞtes HTTP supplĂ©mentaires, chacun une valeur littĂ©rale ou env:VAR. Un en-tĂŞte Authorization y est refusĂ© : utilisez Auth. Les en-tĂŞtes que le transport pose lui-mĂŞme le sont aussi (Mcp-Session-Id, MCP-Protocol-Version, Mcp-Method, Mcp-Name, Last-Event-ID) ; un en-tĂŞte statique ne remplace jamais celui qu'une requĂŞte porte dĂ©jĂ .
  • Url : quand Auth est renseignĂ© ou qu'un en-tĂŞte lit env:VAR, l'adresse doit ĂŞtre https, ou http en loopback, comme TokenUrl : un identifiant n'est jamais envoyĂ© en clair Ă  un autre hĂ´te.
  • Tools : Allow (vide, tous les outils sont gardĂ©s) puis Deny, appliquĂ©s avant que les outils n'atteignent le registre ; un nom prĂ©sent dans les deux est refusĂ©. Une entrĂ©e qui ne correspond Ă  aucun outil listĂ© par le serveur est signalĂ©e par un avertissement (et dans McpServerStatus.UnmatchedToolFilters).
  • CallTimeout : durĂ©e maximale d'un appel d'outil, 60 secondes par dĂ©faut. Un serveur muet termine l'appel en erreur d'outil (McpCallTimeoutException, error_type dans les mĂ©tadonnĂ©es de la rĂ©ponse) ; l'annulation par l'appelant n'est pas un dĂ©lai dĂ©passĂ©. La mĂŞme borne vaut pour prompts/list, prompts/get, resources/list, resources/read et un resources/subscribe legacy (une TimeoutException qui nomme la clĂ©). Une durĂ©e non positive est refusĂ©e ; la borne ne peut pas ĂŞtre dĂ©sactivĂ©e.
  • ConnectTimeout : durĂ©e maximale de la poignĂ©e de main et de la liste des outils, 30 secondes par dĂ©faut, quel que soit l'appelant. Un serveur restĂ© muet fait Ă©chouer la connexion avec une erreur qui nomme MCP:Servers:<id>:ConnectTimeout.

OAuth 2.0. Auth:Type accepte aussi oauth2-client-credentials et oauth2-device (OAuth2ClientCredentials et OAuth2Device sont lus aussi). Les graphies acceptées de Auth:Type sont exactement None, none, Bearer, bearer, Basic, basic, OAuth2ClientCredentials, oauth2-client-credentials, OAuth2Device et oauth2-device ; toute autre, un nombre compris, est refusée avec cette liste, avec ces clés :

"Auth": {
  "Type": "oauth2-client-credentials",
  "TokenUrl": "https://idp.example.com/oauth/token",
  "ClientId": "orkeon-agent",
  "ClientSecretEnv": "TRACKER_OAUTH_CLIENT_KEY",
  "Scopes": [ "tools.call" ],
  "Audience": "https://mcp.example.com"
}
  • TokenUrl (et DeviceAuthorizationUrl pour le device flow) doit ĂŞtre une adresse https absolue, ou http sur la boucle locale : un identifiant n'est jamais postĂ© en clair vers un autre hĂ´te. ClientId est obligatoire ; ClientSecretEnv nomme la variable qui porte le secret du client (obligatoire pour les client credentials, facultative pour le device flow) et se vĂ©rifie au dĂ©marrage puis Ă  chaque demande de jeton. Scopes et Audience sont facultatifs.
  • Le jeton d'accès vit en mĂ©moire seulement et n'est jamais Ă©crit sur disque. Il est renouvelĂ© 60 secondes avant son expiration. Quand le serveur rĂ©pond 401, la requĂŞte repart une fois avec un nouveau jeton ; un second 401 est la rĂ©ponse (l'appel Ă©choue, rien ne boucle). Les requĂŞtes refusĂ©es ensemble partagent un seul renouvellement. Le flux GET, quand le serveur en offre un, se rouvre aussitĂ´t après un renouvellement, une fois de suite, puis temporise.
  • oauth2-device affiche une adresse de vĂ©rification et un code sur le terminal du run (stderr) et attend la personne ; les renouvellements suivants utilisent le jeton de rafraĂ®chissement Ă©mis par le fournisseur, et ne redemandent un code que s'il est refusĂ©. Disponible dans orkeon run et la REPL, qui enregistrent une IOAuthLoginInteraction sur leur console. orkeon-host n'en enregistre aucune : un serveur en oauth2-device y est Ă©cartĂ© au dĂ©marrage avec une erreur qui le nomme ; utilisez oauth2-client-credentials. La connexion se fait avant la poignĂ©e de main de la connexion et avant un appel qui trouve le jeton expirĂ©, hors de ConnectTimeout et CallTimeout : l'attente de la personne est bornĂ©e par la durĂ©e de vie du code d'appareil, pas par ces dĂ©lais. La fermeture d'une session (le DELETE de Mcp-Session-Id) ne lance jamais de connexion.
  • Le point de terminaison de jeton est joint par son propre HttpClient, enregistrĂ© sous le nom orkeon-mcp-oauth (McpServiceExtensions.OAuthHttpClientName), proxy et dĂ©lai par dĂ©faut, sans redirection, exclu du journal d'Ă©changes LLM. Le secret du client et les jetons ne sont jamais Ă©crits dans une erreur ni une ligne de log : ce que le fournisseur d'identitĂ© renvoie en Ă©cho est masquĂ©.
  • Un serveur dont les rĂ©glages sont illisibles (un Auth:Type mal Ă©crit, une durĂ©e invalide) est Ă©cartĂ© au dĂ©marrage avec une ligne qui le nomme et en donne la raison ; les graphies acceptĂ©es de Auth:Type y sont listĂ©es.
  • Non pris en charge : la dĂ©couverte de ressource protĂ©gĂ©e (RFC 9728) et l'enregistrement dynamique de client (DCR) ; les points de terminaison sont des rĂ©glages.

Headers et Auth valent pour le transport HTTP (Sse) ; sur un serveur Stdio ils sont refusés, jamais ignorés en silence. Un serveur dont la configuration est invalide (un en-tête Authorization littéral, un en-tête que pose le transport, une Url en http simple vers un hôte distant avec des identifiants, une variable d'environnement absente, Auth:Type sans nom de variable, un délai non positif, Auth ou Headers sur un serveur Stdio) est écarté au démarrage avec une erreur qui nomme la clé des réglages, jamais une valeur, et le run continue sans ses outils. Tous les serveurs partagent un HttpClient enregistré sous le nom orkeon-mcp (McpServiceExtensions.HttpClientName) ; il est exclu du journal d'échanges LLM, si bien que ni le trafic ni les identifiants n'y sont écrits. Les identifiants sont appliqués par requête par un IMcpRequestAuthenticator, et non portés par le client ; une variable vide au moment d'une requête fait échouer cette requête avec la même erreur nommant la clé, au lieu de l'envoyer sans authentification. Le client ne suit aucune redirection HTTP : une réponse 3xx est un échec, si bien que les en-têtes statiques et les identifiants n'atteignent jamais un autre hôte que celui configuré.

Rien n'est développé dans la section. Command, Args et Env passent tels qu'ils sont écrits, et le serveur hérite de l'environnement où tourne Orkeon : une référence ${NOM} ou %NOM% dans Command, Args, Url ou une valeur d'Env refuse le démarrage, avant la connexion d'un serveur, avec sa correction (une référence de variable n'est jamais développée).

L'hôte partagé des runners honore la section de lui-même. orkeon run — et tout runner bâti sur RunnerHost — appelle AddOrkeonMcp dès que MCP:Servers déclare au moins un serveur et que MCP:Enabled n'est pas false, puis connecte chaque serveur dans un pas de démarrage explicite (McpStartup) avant le chargement de la crew — et avant que --validate juge la crew et que --list-tools imprime le manifeste, pour que les trois voient la même surface d'outils. Un serveur qui ne peut pas être connecté (commande inexistante, point de terminaison muet, poignée de main toujours en attente après 30 s) coûte une ligne d'erreur qui le nomme, dans le journal et sur stderr, et le run continue. La sortie d'erreur d'un serveur stdio est lue au fil de l'eau — chaque ligne va au journal en Debug (MCP server '<id>' stderr: …), si bien qu'un serveur qui y écrit beaucoup ne s'y bloque jamais — et un serveur qui s'arrête avant de répondre dit pourquoi : son code de sortie et la dernière ligne écrite sur sa sortie d'erreur rejoignent cette ligne d'erreur (Transport disconnected: the MCP server exited with code 1; its last line on stderr: …). Les outils sont enregistrés sous leur propre nom, sans préfixe de serveur, et un nom déjà tenu par le registre — un outil intégré, un outil de script ou l'outil d'un serveur connecté plus tôt — est refusé : l'outil MCP n'est pas enregistré, une ligne d'erreur nomme le serveur et l'outil (The tool 'file_read' of MCP server 'x' collides with an already-registered tool and was not registered), dans le journal et sur stderr, et l'outil qui tenait le nom le garde, y compris après la déconnexion de ce serveur. Les autres outils du serveur sont enregistrés normalement (--list-tools montre la surface fusionnée). orkeon-host les connecte aussi : bâti sur RunnerHost, il lit la même section et exécute le même pas, une fois, depuis son premier service hébergé, au démarrage du démon — avant que le canal de chat puisse livrer un message qui charge une crew — et déconnecte les serveurs à l'arrêt, après le drainage. Les mêmes réglages donnent à orkeon run et à orkeon-host les mêmes outils ; un serveur injoignable coûte la même ligne d'erreur et le démon démarre sans lui. Dans tout autre hôte qui embarque, MCP reste une surface bibliothèque — l'hôte appelle lui-même AddOrkeonMcp(configuration) (ou la surcharge config) et connecte lui-même les serveurs.

orkeon-repl, et les scripts. orkeon-repl enregistre la section de la même façon et connecte les serveurs avant de charger ses commandes ; un serveur qui échoue coûte la même ligne, et le REPL démarre. Les outils qu'apporte un serveur entrent dans le registre d'outils, et le catalogue des scripts le lit à côté des outils du conteneur (ScriptToolCatalogue) : l'espace de noms tools d'une commande, le .tools([...]) d'un agent dans une crew .ork.ts et ctx.llm.act atteignent les outils d'un serveur MCP — dans le REPL, et sous orkeon run, où les serveurs d'un script procédural sont connectés avant qu'il tourne. Whisper par MCP branche ainsi un serveur de transcription.

La bibliothèque ne livre pas de hosted service pour cela : un hôte qui embarque résout McpToolProvider et appelle explicitement ConnectServerAsync(serverId, config) pour chaque serveur configuré — exactement ce que fait le pas de démarrage de l'hôte des runners, et ce qu'appelle le service de connexion d'orkeon-host. Un hôte qui sert ses outils appelle AddOrkeonMcpServer(configuration), puis résout McpServer et lance RunStdioAsync(reader, writer) sur les flux qu'il possède — ce que fait orkeon mcp serve. orkeon-host ne sert pas MCP.

Outils MCP et crews

Un outil MCP connecté est un outil comme les autres : un agent de crew le liste par son nom, en YAML ou dans un script .ork.ts, et le reçoit.

agents:
  analyst:
    tools: [search_issues]   # un outil exposé par un serveur MCP déclaré dans MCP:Servers

CrewFactory attache tout outil que le registre résout ; il n'y a pas d'interface plus étroite qu'IBaseTool à implémenter. Les serveurs sont connectés avant le chargement de la crew : sous StrictTools — le défaut des runners — une crew qui nomme l'outil d'un serveur qui n'a pas pu être connecté échoue au chargement avec la ligne ordinaire unknown tool(s). --list-tools et --validate voient les outils MCP, McpServer ré-expose ce que contient le registre — tous les outils, ou ceux que nomme orkeon mcp serve --tools (AllowedTools) ; l'hôte d'orkeon mcp serve n'enregistre pas human_input —, et du code C# peut en résoudre un par IToolRegistry.GetToolByNameAsync(name). Le décorateur des runs observés de --events jsonl enveloppe les outils enregistrés dans la DI ; les outils MCP arrivent dans le registre à l'exécution et ne sont pas enveloppés.

Servir les outils avec orkeon mcp serve

orkeon mcp serve [--settings <fichier>] [--tools a,b,…] [--max-concurrency <n>] [--expose-output] [--crew <a.yaml> [<b.yaml> …]] [--allow-external-mounts]

Le verbe sert les outils d'un hôte Orkeon à un client MCP sur stdio — le transport par lequel Claude Desktop, les éditeurs et les frameworks d'agents démarrent un serveur local : le client lance le processus, écrit un message JSON-RPC par ligne sur son stdin et lit les réponses sur son stdout, une par ligne ; fermer stdin arrête le serveur.

  • L'hĂ´te est celui que construit un run. Les rĂ©glages se rĂ©solvent comme ceux d'orkeon run, ancrĂ©s au rĂ©pertoire courant : --settings, sinon appsettings.json Ă  cet endroit, sinon un appsettings/appsettings.json trouvĂ© en remontant, sinon le fichier par utilisateur d'orkeon init, sinon les seules variables d'environnement ORKEON_* ; le fichier retenu est nommĂ© sur stderr. Les montages qu'il dĂ©clare (Orkeon:FileSystem:Mounts) sont ce qu'atteignent les outils de fichiers, et les serveurs MCP qu'il dĂ©clare sous MCP:Servers sont connectĂ©s d'abord, leurs outils servis aussi. Ce qui est servi est ce qu'imprime orkeon run --list-tools pour les mĂŞmes rĂ©glages, human_input Ă  part : cet outil rĂ©pond pour l'opĂ©rateur d'un run, et le client d'un serveur MCP a son propre humain. Aucune crew n'est chargĂ©e, donc aucun outil que dĂ©clare une crew .ork.ts n'est servi : ceux-lĂ  sont enregistrĂ©s au chargement de leur crew.
  • --crew <a.yaml> [<b.yaml> …] sert des crews comme outils. Plusieurs crews se suivent, sĂ©parĂ©es par des espaces, après un seul drapeau, qu'on ne peut pas rĂ©pĂ©ter (comme --mount). Chaque crew est chargĂ©e une fois au dĂ©marrage par le point d'entrĂ©e avec lequel orkeon run et orkeon eval run --crew chargent une crew, dans un hĂ´te Ă  elle qui porte ce qu'orkeon run donne Ă  une crew : les rĂ©glages (--settings, sinon rĂ©solus depuis le dossier de la crew), le budget, le gardien et la barrière de permissions (Orkeon:Security:PermissionGate, un ask est refusĂ© sans canal). Une crew qui ne se charge pas, un dossier hors du rĂ©pertoire courant sans --allow-external-mounts, deux crews qui donnent un mĂŞme nom, ou un nom run_crew_* qu'un outil de l'hĂ´te porte dĂ©jĂ  refusent le dĂ©marrage, avec le nom. Seules les crews nommĂ©es sont servies : aucun outil ne prend de chemin.
    • L'outil est run_crew_<nom> : le name de la crew, en minuscules, chaque suite d'autres caractères devenant un tiret bas. Son inputSchema est un objet Ă  une propriĂ©tĂ© chaĂ®ne obligatoire par {placeholder} trouvĂ© dans les description et expectedOutput des tâches (comparĂ©s sans tenir compte de la casse, dans l'ordre de première apparition) et aucune autre propriĂ©tĂ©. Un nombre ou un boolĂ©en est lu comme son texte ; un objet, un tableau ou null est refusĂ©, de mĂŞme qu'un argument inconnu ou manquant (-32602, noms listĂ©s). Le rĂ©sultat est la sortie finale de la crew ; une crew qui Ă©choue est un rĂ©sultat isError, pas une erreur JSON-RPC.
    • Progression : quand l'appel porte _meta.progressToken, le serveur envoie une notifications/progress par tâche terminĂ©e (progress de 1 Ă  total, le nombre de tâches, avec un message) avant la rĂ©ponse ; sans jeton rien n'est envoyĂ©. notifications/cancelled annule le run.
    • Prompts : chaque tâche est le prompt <nom>_task_<n> (Ă  partir de 1), ses arguments les placeholders de cette tâche, le message sa description et sa sortie attendue interpolĂ©es. La capacitĂ© prompts n'est annoncĂ©e qu'avec --crew.
    • Les appels d'une mĂŞme crew s'exĂ©cutent un par un. L'hĂ´te de la crew est partagĂ© par ses appels, et avec lui ce qu'il monte (/output, AUTO_SUMMARY.md, les checkpoints) : un second appel attend le premier (les appels d'autres crews, et tous les autres outils, s'exĂ©cutent Ă  cĂ´tĂ©). Chaque appel tourne tout de mĂŞme dans un scope Ă  lui, avec son propre Ă©tat de tâches, et un notifications/cancelled du client annule la crew en cours : ses agents voient le jeton et l'appel n'est pas rĂ©pondu.
    • Le run est enregistrĂ© comme tout run de l'hĂ´te. Avec Orkeon:RunHistory:Enabled activĂ© dans les rĂ©glages de la crew, chaque appel est un run de l'historique : run.started, les Ă©vĂ©nements de tâche, run.finished, sous son propre identifiant de run (celui des checkpoints), lu avec orkeon runs. Historique Ă©teint, rien n'est Ă©crit. run.finished porte success, exitCode, durationMs, cappedTasks et missingDeliverables, et aucun champ de tokens (voir le bus d'Ă©vĂ©nements de run). Les Ă©vĂ©nements ne portent pas de compte de tokens : l'usage du modèle n'est pas attribuĂ© par appel.
    • Il n'y a pas de mode hors ligne. L'hĂ´te du serveur lit les vrais rĂ©glages et une crew appelle les modèles qu'ils dĂ©clarent ; le fournisseur mock ne s'atteint qu'en pointant les profils vers lui.
    • Le total de la progression est le nombre de tâches de la crew ; une relance ou un manager hiĂ©rarchique peut exĂ©cuter plus de tentatives que cela, et la progression s'arrĂŞte alors Ă  total.
  • La permission gate n'est pas consultĂ©e pour les appels du client (GateExempt). Les appels du serveur passent par le point d'invocation gardĂ© (Guardian, assainisseur de rĂ©sultat, audit) sous l'appelant mcp, marquĂ© GateExempt : le client IA qui a lancĂ© orkeon mcp serve sur stdio ne passe pas par l'IPermissionGate. La raison : le client est l'agent de l'opĂ©rateur, qui a dĂ©jĂ  choisi ce qu'il peut atteindre (les rĂ©glages, --tools, les montages) ; stdout porte le protocole, un ask n'aurait aucun canal vers un humain et tout appel Ă  approuver serait refusĂ©. Une crew servie avec --crew est un autre cas : ses propres agents passent par la permission gate comme dans orkeon run.
  • --tools a,b,… ne sert que les outils nommĂ©s (sĂ©parĂ©s par des virgules) ; un nom que l'hĂ´te n'a pas refuse le dĂ©marrage en le nommant. Les autres outils ne sont ni listĂ©s ni appelables, mĂŞme ceux qu'un serveur MCP amont enregistre plus tard (tools/list_changed) : la liste blanche est celle du serveur (MCP:Server:AllowedTools), pas un dĂ©senregistrement. Les outils de --crew n'y sont pas soumis.
  • Les requĂŞtes s'exĂ©cutent en concurrence (--max-concurrency <n>, au moins 1, 4 par dĂ©faut, ou MCP:Server:MaxConcurrency). Chaque requĂŞte est une tâche ; n au plus tournent Ă  la fois et les autres attendent leur tour : un cinquième appel lent dĂ©marre quand l'un des quatre premiers se termine. Un appel de --crew ne tient aucun emplacement : il attend sa crew (une exĂ©cution Ă  la fois par crew), donc tools/list et ping restent servis. Les rĂ©ponses passent par un canal vers un seul Ă©crivain : deux rĂ©ponses ne s'entrelacent jamais sur stdout, et elles peuvent arriver dans un autre ordre que les requĂŞtes (le client les rapproche par id). Quand stdin se ferme, chaque requĂŞte dĂ©jĂ  lue reçoit sa rĂ©ponse avant que le serveur ne s'arrĂŞte.
  • notifications/cancelled annule la requĂŞte que nomme son requestId, qu'elle tourne ou qu'elle attende son tour : l'appel d'outil reçoit l'annulation, et une requĂŞte annulĂ©e n'est jamais rĂ©pondue, comme la spĂ©cification le demande. Un identifiant inconnu du serveur est ignorĂ©. Une seconde requĂŞte dont l'identifiant est dĂ©jĂ  en vol est refusĂ©e (-32600). McpServer est un singleton sans dĂ©pendance scoped : une requĂŞte n'a pas de portĂ©e DI propre.
  • --expose-output (ou MCP:Server:ExposeOutput) sert /output comme ressources en lecture seule, dĂ©sactivĂ© par dĂ©faut. resources/list pagine les fichiers sous /output par ordre de chemin (ResourcesPageSize par page, un nextCursor opaque), chacun sous la forme orkeon:///output/<chemin> avec son name, son mimeType et sa size ; resources/read rend un fichier en text quand c'est du texte UTF-8 et en blob base64 sinon, jusqu'Ă  MaxResourceBytes. Tout passe par IFileSystemService : le montage /output doit exister et accorder Read (un avertissement sur stderr le dit quand il n'est pas montĂ©), et l'URI est analysĂ©e strictement — aucun segment ./../vide, ni requĂŞte ni fragment, ni %2f, tout autre que orkeon:///output/… est refusĂ©. /workspace et tout autre montage ne sont jamais exposĂ©s, aucune URI ni erreur ne porte de chemin physique, et il n'y a ni resources/subscribe ni resources/templates/list. Sans l'option, resources/* rĂ©pondent Method not found.
  • Chaque appel est gardĂ© : le point d'invocation du serveur, sous l'appelant mcp — un appel bloquĂ© n'atteint jamais l'outil, un rĂ©sultat arrive tronquĂ© et Ă©tiquetĂ© comme donnĂ©e, et la piste d'audit enregistre chaque appel sous l'agent mcp ; un appel bloquĂ© ou en Ă©chec atteint aussi stderr, par le puits de journal de la piste (Agent=mcp).
  • Stdout ne porte que le protocole. Chaque ligne de journal, avertissement et diagnostic va sur stderr — lĂ  oĂą un client MCP enregistre la sortie d'un serveur —, de mĂŞme que --help et les erreurs d'usage.
  • Codes de sortie : 0 le client a fermĂ© le flux (ou --help) ; 1 une erreur d'usage, un rĂ©glage refusĂ© (une clĂ© inconnue, un montage dĂ©clarĂ© par les rĂ©glages qui ne peut pas ĂŞtre montĂ©, tout autre rĂ©glage que refuse l'hĂ´te des runners — une ligne ERROR: le nomme), un nom de --tools que l'hĂ´te n'a pas, un --crew refusĂ© au dĂ©marrage (une crew qui ne se charge pas, un nom donnĂ© deux fois, un nom run_crew_* dĂ©jĂ  tenu par un outil), un serveur lancĂ© par un autre (plus bas) ; 2 une erreur inattendue. Ctrl+C ou SIGTERM termine le serveur avec 0, les crews et les serveurs amont Ă©tant libĂ©rĂ©s Ă  la sortie.

Une configuration client — le claude_desktop_config.json de Claude Desktop :

{
  "mcpServers": {
    "orkeon": {
      "command": "orkeon",
      "args": ["mcp", "serve", "--settings", "/home/moi/orkeon/appsettings.json"]
    }
  }
}

Un client démarre ses serveurs dans un répertoire de travail de son choix : nommez le fichier de réglages avec --settings, ou comptez sur le fichier par utilisateur d'orkeon init.

Un serveur ne démarre jamais sous un autre. Avant de connecter les serveurs MCP de ses réglages, un serveur pose ORKEON_MCP_SERVE dans son propre environnement — chaque processus qu'il lance en hérite, et la variable est retirée quand il s'arrête — et un serveur qui la trouve posée refuse de démarrer : code 1, et une ligne sur stderr, que le serveur qui l'a lancé joint à son erreur de connexion (orkeon mcp serve: refused to start: another `orkeon mcp serve` started this one (ORKEON_MCP_SERVE is set), …). Des réglages qui déclarent orkeon mcp serve lui-même sous MCP:Servers coûtent donc cette seule ligne : retirez l'entrée, ou déclarez les deux serveurs côté client. orkeon run et orkeon-host ne posent aucun marqueur, et peuvent utiliser un orkeon mcp serve lancé sur d'autres réglages. Comme ORKEON_DEBUG, la variable est aussi lue par la couche de configuration ORKEON_, comme une clé (MCP_SERVE) qui n'est aucun réglage.

Notifications, pagination et prompts (le client)

  • Pagination. tools/list, resources/list et prompts/list suivent nextCursor jusqu'Ă  une page qui n'en nomme aucun (McpClient.ListToolsAsync, ListResourcesAsync, ListPromptsAsync). Un serveur dont le curseur ne finit jamais fait Ă©chouer la liste au bout de 100 pages, ou de 10 000 Ă©lĂ©ments, (InvalidOperationException) au lieu de la laisser grossir sans fin.
  • Notifications. Une trame sans id est une notification : IMcpTransport.Notifications est un ChannelReader<JsonRpcNotification> (256 entrĂ©es, DropOldest, un avertissement par entrĂ©e perdue). Le transport stdio l'alimente depuis la sortie du serveur ; le transport HTTP, avec les notifications d'une rĂ©ponse encadrĂ©e en SSE (Ă  mesure qu'elles arrivent, pas après son message final), du flux GET et de subscriptions/listen. Une requĂŞte que le serveur envoie au client (sampling/createMessage, roots/list, elicitation/create) reçoit -32601 sur stdio et sur HTTP : le client n'en offre aucune ; un ping en HTTP reçoit le rĂ©sultat vide que la spĂ©cification exige.
  • Abonnements. Sur un serveur moderne en HTTP, McpToolProvider garde ouverte une requĂŞte subscriptions/listen (McpClient.ListenAsync : changements de listes d'outils, de prompts et de ressources, plus les ressources abonnĂ©es) ; quand le serveur termine le flux, il est rouvert après le mĂŞme dĂ©lai croissant et la liste d'outils est marquĂ©e pĂ©rimĂ©e, puisque ce que le serveur a dit entre-temps est perdu. Un serveur qui refuse la requĂŞte n'est plus sollicitĂ©. Le flux n'est pas bornĂ© par CallTimeout. Sur un serveur legacy, McpToolProvider.SubscribeResourceAsync envoie resources/subscribe (UnsubscribeResourceAsync y met fin et abandonne la lecture en cache) (refusĂ© quand le serveur n'annonce pas resources.subscribe) et les mises Ă  jour arrivent sur le flux GET. Un notifications/resources/updated n'invalide que la lecture en cache de cette ressource (McpToolProvider.ReadResourceAsync met en cache les lectures des ressources abonnĂ©es, et elles seules, et une lecture en vol quand la mise Ă  jour arrive n'est pas gardĂ©e) ; les outils ne sont pas listĂ©s de nouveau. Quand le flux GET est rouvert ou la session rĂ©initialisĂ©e, le cache est abandonnĂ© et les abonnements sont renvoyĂ©s, puisque les notifications du trou sont perdues.
  • notifications/tools/list_changed. McpToolProvider surveille chaque serveur connectĂ©. Après une attente de 500 ms (les notifications arrivĂ©es entre-temps sont absorbĂ©es) il liste de nouveau les outils, applique le filtre Tools du serveur, dĂ©senregistre les outils que le serveur a retirĂ©s, remplace ceux dont la dĂ©finition a changĂ© par un nouvel adaptateur en une seule Ă©tape du registre (IToolRegistry.ReplaceToolAsync : le nom ne cesse jamais de se rĂ©soudre), et enregistre les nouveaux. Un nom qu'un autre outil dĂ©tient (un intĂ©grĂ©, un outil de script, l'outil d'un autre serveur) lui reste et est signalĂ© par l'avertissement mcp.tool.rejected ; McpServerStatus.RejectedToolNames le nomme. Une tâche dĂ©jĂ  en cours garde les instances d'outils qu'elle a reçues : seule la crew construite ensuite voit le nouvel ensemble. Les notifications sont lues dès leur arrivĂ©e : un flot d'autres trames ne peut pas chasser un list_changed du canal bornĂ©, et un list_changed arrivĂ© pendant une nouvelle liste en dĂ©clenche une autre. Une nouvelle liste qui Ă©choue garde les outils enregistrĂ©s jusque-lĂ  et est journalisĂ©e.
  • Prompts. McpClient.ListPromptsAsync et GetPromptAsync(name, arguments) parlent prompts/*. L'outil intĂ©grĂ© mcp_prompt_get (server, name, arguments) remet un prompt Ă  un agent, ou liste les prompts du serveur quand name est vide ; AddOrkeonMcp l'enregistre. Le texte d'un prompt est un contenu non fiable du serveur et un vecteur d'injection de prompt : il arrive au modèle comme rĂ©sultat d'un appel d'outil, rien de plus, et un serveur peut y mettre des instructions. L'outil dĂ©clare ToolAccess.Read : la permission gate laisse donc passer l'appel sans demander, dans tous les modes. Ne connectez que des serveurs de confiance, ou gardez l'outil hors des tools: d'un agent qui ne doit pas lire leurs prompts.

Limites honnĂŞtes

Alignées sur Limitations connues :

  • Abonnements — subscriptions/listen ne tourne qu'en HTTP (le client stdio entend chaque notification que le serveur envoie) ; la forme du filtre 2026-07-28 (notifications.toolsListChanged, promptsListChanged, resourcesListChanged, resourceSubscriptions) est celle que ce client envoie, vĂ©rifiĂ©e contre ses propres faux serveurs et le serveur de rĂ©fĂ©rence, pas encore contre le schĂ©ma publiĂ©.
  • Ni sampling, ni roots, ni elicitation — une requĂŞte du serveur pour l'un d'eux reçoit -32601 : le sampling ferait appeler un LLM par Orkeon pour le serveur hors du budget, du gardien et du coĂ»t d'un run ; les roots exposeraient des chemins physiques (règle VFS) ; l'elicitation attend le human-in-the-loop durable.
  • Pas de requĂŞtes multi-aller-retour (MRTR) — un rĂ©sultat intermĂ©diaire moderne input_required remonte comme une erreur d'outil explicite, jamais comme des donnĂ©es partielles.
  • OAuth se limite aux client credentials et au device flow — pas de flux authorization-code, pas de dĂ©couverte de ressource protĂ©gĂ©e (RFC 9728), pas d'enregistrement dynamique de client (DCR) ; le device flow demande un hĂ´te avec terminal (pas orkeon-host) ; les jetons ne sont jamais persistĂ©s, une connexion device est redemandĂ©e au run suivant.
  • HTTP+SSE 2024-11-05 non supportĂ© — le transport Ă  endpoint de messages sĂ©parĂ© est refusĂ© ; Streamable HTTP est le transport HTTP. L'interop contre le serveur de rĂ©fĂ©rence tourne chaque nuit (McpReferenceServerInteropTests, Interop MCP).
  • 2025-03-26 exclue (batching JSON-RPC obligatoire).
  • Le serveur ne parle que stdio (orkeon mcp serve, ou RunStdioAsync / ProcessRequestAsync dans un hĂ´te C#) : pas de transport HTTP, des prompts et des crews comme outils seulement pour les crews que nomme --crew (un client ne donne jamais de chemin), et les ressources se limitent Ă  /output (lecture seule, pas de resources/subscribe).

Statut expérimental

Chaque type MCP porte [Experimental("ORKEXP004")] : y faire référence depuis votre code est une erreur de compilation tant que le diagnostic n'est pas supprimé — cette suppression vaut opt-in et reconnaissance que la surface (notamment les types wire) peut encore bouger. Voir APIs expérimentales.


Voir aussi : Sous-systèmes opt-in · APIs expérimentales · Limitations connues · Retour à l'index