@breign/client 1.0.177 → 1.0.178

package/dist/apis/McpApi.d.ts

@@ -17,6 +17,9 @@ export interface DeleteMcpSessionRequest {
 export interface GetMcpStreamRequest {
     organizationId: string;
 }
+export interface HandleBuilderMcpRequestRequest {
+    mcpJsonRpcRequestUio: McpJsonRpcRequestUio;
+}
 export interface HandleMcpRequestRequest {
     organizationId: string;
     mcpJsonRpcRequestUio: McpJsonRpcRequestUio;
@@ -25,6 +28,16 @@ export interface HandleMcpRequestRequest {
  *
  */
 export declare class McpApi extends runtime.BaseAPI {
+    /**
+     * Aucune session à clore : le transport est sans état.
+     * Not supported (stateless MCP server)
+     */
+    deleteBuilderMcpSessionRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>>;
+    /**
+     * Aucune session à clore : le transport est sans état.
+     * Not supported (stateless MCP server)
+     */
+    deleteBuilderMcpSession(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void>;
     /**
      * Aucune session à clore : le transport est sans état.
      * Not supported (stateless MCP server)
@@ -35,6 +48,16 @@ export declare class McpApi extends runtime.BaseAPI {
      * Not supported (stateless MCP server)
      */
     deleteMcpSession(organizationId: string, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void>;
+    /**
+     * Pas de flux SSE côté serveur : le transport est sans état.
+     * Not supported (stateless MCP server)
+     */
+    getBuilderMcpStreamRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>>;
+    /**
+     * Pas de flux SSE côté serveur : le transport est sans état.
+     * Not supported (stateless MCP server)
+     */
+    getBuilderMcpStream(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void>;
     /**
      * Pas de flux SSE côté serveur : le transport est sans état.
      * Not supported (stateless MCP server)
@@ -45,6 +68,16 @@ export declare class McpApi extends runtime.BaseAPI {
      * Not supported (stateless MCP server)
      */
     getMcpStream(organizationId: string, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void>;
+    /**
+     * Serveur MCP (Model Context Protocol, transport Streamable HTTP, sans état) qui crée et édite les agents des organisations de l\'utilisateur : de quoi brancher Claude Code, ou tout client MCP, sur la configuration de Breign. Lié à la clé et non à une organisation : chaque outil vérifie que l\'utilisateur est membre de celle qu\'il touche. Distinct du serveur `/organizations/{organizationId}/mcp`, qui ne sert qu\'à interroger les agents : brancher l\'un ne donne pas les droits d\'écriture de l\'autre.  Authentification par clé API personnelle (`x-api-key` ou `Authorization: Bearer ai-…`) ; les credentials d\'app et la clé maître sans `x-user-id` sont refusés. Chaque action est faite au nom du propriétaire de la clé, avec ses droits.  Outils exposés — lecture : - `list_organizations` — organisations dont l\'utilisateur est membre. - `list_agents` `{ organizationId }` — agents de l\'organisation. - `get_agent` `{ agentId }` — configuration d\'un agent : textes, moteur, skills et bases de   connaissance rattachés.  - `list_engines` `{ organizationId }` — providers de l\'organisation et leurs modèles. - `list_skills` `{ organizationId }` — skills de l\'organisation. - `list_knowledge_bases` `{ organizationId }` — bases de connaissance de l\'organisation.  Outils exposés — écriture (jamais de suppression ni de détachement) : - `create_agent` `{ organizationId, name, persona, promptInit?, description?, role?,   defaultLanguage? }`.  - `update_agent` `{ agentId, name?, description?, role?, defaultLanguage?, persona?,   promptInit?, isActivated? }` — `null` ou absent : champ inchangé.  - `set_agent_engine` `{ agentId, providerId, model }`. - `attach_skill` `{ agentId, skillId }` — ajoute un skill, sans retirer les autres. - `attach_knowledge_base` `{ agentId, knowledgeBaseId }` — ajoute une base, sans retirer les   autres.   Un agent Breign dont `builderMcpConfiguration.enabled` est vrai reçoit les mêmes outils, au nom de l\'utilisateur de la conversation, bornés à l\'organisation de l\'agent (ni `list_organizations` ni `organizationId`) ; chaque écriture lui demande alors son approbation.  Configuration d\'un client, par exemple Claude Code : `claude mcp add --transport http breign-builder https://<api>/mcp/builder --header \"Authorization: Bearer ai-…\"`. Le client doit accepter `application/json` et `text/event-stream` (header `Accept`).
+     * Builder MCP server
+     */
+    handleBuilderMcpRequestRaw(requestParameters: HandleBuilderMcpRequestRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<McpJsonRpcResponseUio>>;
+    /**
+     * Serveur MCP (Model Context Protocol, transport Streamable HTTP, sans état) qui crée et édite les agents des organisations de l\'utilisateur : de quoi brancher Claude Code, ou tout client MCP, sur la configuration de Breign. Lié à la clé et non à une organisation : chaque outil vérifie que l\'utilisateur est membre de celle qu\'il touche. Distinct du serveur `/organizations/{organizationId}/mcp`, qui ne sert qu\'à interroger les agents : brancher l\'un ne donne pas les droits d\'écriture de l\'autre.  Authentification par clé API personnelle (`x-api-key` ou `Authorization: Bearer ai-…`) ; les credentials d\'app et la clé maître sans `x-user-id` sont refusés. Chaque action est faite au nom du propriétaire de la clé, avec ses droits.  Outils exposés — lecture : - `list_organizations` — organisations dont l\'utilisateur est membre. - `list_agents` `{ organizationId }` — agents de l\'organisation. - `get_agent` `{ agentId }` — configuration d\'un agent : textes, moteur, skills et bases de   connaissance rattachés.  - `list_engines` `{ organizationId }` — providers de l\'organisation et leurs modèles. - `list_skills` `{ organizationId }` — skills de l\'organisation. - `list_knowledge_bases` `{ organizationId }` — bases de connaissance de l\'organisation.  Outils exposés — écriture (jamais de suppression ni de détachement) : - `create_agent` `{ organizationId, name, persona, promptInit?, description?, role?,   defaultLanguage? }`.  - `update_agent` `{ agentId, name?, description?, role?, defaultLanguage?, persona?,   promptInit?, isActivated? }` — `null` ou absent : champ inchangé.  - `set_agent_engine` `{ agentId, providerId, model }`. - `attach_skill` `{ agentId, skillId }` — ajoute un skill, sans retirer les autres. - `attach_knowledge_base` `{ agentId, knowledgeBaseId }` — ajoute une base, sans retirer les   autres.   Un agent Breign dont `builderMcpConfiguration.enabled` est vrai reçoit les mêmes outils, au nom de l\'utilisateur de la conversation, bornés à l\'organisation de l\'agent (ni `list_organizations` ni `organizationId`) ; chaque écriture lui demande alors son approbation.  Configuration d\'un client, par exemple Claude Code : `claude mcp add --transport http breign-builder https://<api>/mcp/builder --header \"Authorization: Bearer ai-…\"`. Le client doit accepter `application/json` et `text/event-stream` (header `Accept`).
+     * Builder MCP server
+     */
+    handleBuilderMcpRequest(mcpJsonRpcRequestUio: McpJsonRpcRequestUio, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<McpJsonRpcResponseUio | null | undefined>;
     /**
      * Serveur MCP (Model Context Protocol, transport Streamable HTTP, sans état) par lequel les agents locaux — Claude Code, Pi, Hermes… — interrogent les agents Breign de l\'organisation.  Authentification par clé API personnelle (`x-api-key` ou `Authorization: Bearer ai-…`) ; les credentials d\'app et la clé maître sans `x-user-id` sont refusés. Seuls les agents dont `mcpExposureConfiguration.enabled` est vrai sont joignables.  Outils exposés : - `list_agents` — agents joignables, avec leur rôle et leur description. - `ask_agent` `{ agentId, message, conversationId?, waitSeconds? }` — pose une question ;   attend la réponse jusqu\'à `waitSeconds` (25 s par défaut, 50 s max), sinon rend un ticket.  - `wait_for_reply` `{ ticket, timeoutSeconds? }` — attend la réponse d\'un ticket (45 s par   défaut, 50 s max).   Chaque question vit dans une conversation de tâche au nom du propriétaire de la clé. L\'agent interrogé peut consulter d\'autres agents ou poser une question à un humain (outil Human_ask) : le statut vaut alors `waiting_human`, parfois pendant des heures.  Configuration d\'un client, par exemple Claude Code : `claude mcp add --transport http breign https://<api>/organizations/<organizationId>/mcp --header \"Authorization: Bearer ai-…\"`. Le client doit accepter `application/json` et `text/event-stream` (header `Accept`).
      * MCP server for local agents

package/dist/apis/McpApi.js

@@ -53,6 +53,31 @@ const index_1 = require("../models/index");
  *
  */
 class McpApi extends runtime.BaseAPI {
+    /**
+     * Aucune session à clore : le transport est sans état.
+     * Not supported (stateless MCP server)
+     */
+    async deleteBuilderMcpSessionRaw(initOverrides) {
+        const queryParameters = {};
+        const headerParameters = {};
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["X-API-Key"] = await this.configuration.apiKey("X-API-Key"); // ApiKeyAuth authentication
+        }
+        const response = await this.request({
+            path: `/mcp/builder`,
+            method: 'DELETE',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+        return new runtime.VoidApiResponse(response);
+    }
+    /**
+     * Aucune session à clore : le transport est sans état.
+     * Not supported (stateless MCP server)
+     */
+    async deleteBuilderMcpSession(initOverrides) {
+        await this.deleteBuilderMcpSessionRaw(initOverrides);
+    }
     /**
      * Aucune session à clore : le transport est sans état.
      * Not supported (stateless MCP server)
@@ -81,6 +106,31 @@ class McpApi extends runtime.BaseAPI {
     async deleteMcpSession(organizationId, initOverrides) {
         await this.deleteMcpSessionRaw({ organizationId: organizationId }, initOverrides);
     }
+    /**
+     * Pas de flux SSE côté serveur : le transport est sans état.
+     * Not supported (stateless MCP server)
+     */
+    async getBuilderMcpStreamRaw(initOverrides) {
+        const queryParameters = {};
+        const headerParameters = {};
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["X-API-Key"] = await this.configuration.apiKey("X-API-Key"); // ApiKeyAuth authentication
+        }
+        const response = await this.request({
+            path: `/mcp/builder`,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+        return new runtime.VoidApiResponse(response);
+    }
+    /**
+     * Pas de flux SSE côté serveur : le transport est sans état.
+     * Not supported (stateless MCP server)
+     */
+    async getBuilderMcpStream(initOverrides) {
+        await this.getBuilderMcpStreamRaw(initOverrides);
+    }
     /**
      * Pas de flux SSE côté serveur : le transport est sans état.
      * Not supported (stateless MCP server)
@@ -109,6 +159,44 @@ class McpApi extends runtime.BaseAPI {
     async getMcpStream(organizationId, initOverrides) {
         await this.getMcpStreamRaw({ organizationId: organizationId }, initOverrides);
     }
+    /**
+     * Serveur MCP (Model Context Protocol, transport Streamable HTTP, sans état) qui crée et édite les agents des organisations de l\'utilisateur : de quoi brancher Claude Code, ou tout client MCP, sur la configuration de Breign. Lié à la clé et non à une organisation : chaque outil vérifie que l\'utilisateur est membre de celle qu\'il touche. Distinct du serveur `/organizations/{organizationId}/mcp`, qui ne sert qu\'à interroger les agents : brancher l\'un ne donne pas les droits d\'écriture de l\'autre.  Authentification par clé API personnelle (`x-api-key` ou `Authorization: Bearer ai-…`) ; les credentials d\'app et la clé maître sans `x-user-id` sont refusés. Chaque action est faite au nom du propriétaire de la clé, avec ses droits.  Outils exposés — lecture : - `list_organizations` — organisations dont l\'utilisateur est membre. - `list_agents` `{ organizationId }` — agents de l\'organisation. - `get_agent` `{ agentId }` — configuration d\'un agent : textes, moteur, skills et bases de   connaissance rattachés.  - `list_engines` `{ organizationId }` — providers de l\'organisation et leurs modèles. - `list_skills` `{ organizationId }` — skills de l\'organisation. - `list_knowledge_bases` `{ organizationId }` — bases de connaissance de l\'organisation.  Outils exposés — écriture (jamais de suppression ni de détachement) : - `create_agent` `{ organizationId, name, persona, promptInit?, description?, role?,   defaultLanguage? }`.  - `update_agent` `{ agentId, name?, description?, role?, defaultLanguage?, persona?,   promptInit?, isActivated? }` — `null` ou absent : champ inchangé.  - `set_agent_engine` `{ agentId, providerId, model }`. - `attach_skill` `{ agentId, skillId }` — ajoute un skill, sans retirer les autres. - `attach_knowledge_base` `{ agentId, knowledgeBaseId }` — ajoute une base, sans retirer les   autres.   Un agent Breign dont `builderMcpConfiguration.enabled` est vrai reçoit les mêmes outils, au nom de l\'utilisateur de la conversation, bornés à l\'organisation de l\'agent (ni `list_organizations` ni `organizationId`) ; chaque écriture lui demande alors son approbation.  Configuration d\'un client, par exemple Claude Code : `claude mcp add --transport http breign-builder https://<api>/mcp/builder --header \"Authorization: Bearer ai-…\"`. Le client doit accepter `application/json` et `text/event-stream` (header `Accept`).
+     * Builder MCP server
+     */
+    async handleBuilderMcpRequestRaw(requestParameters, initOverrides) {
+        if (requestParameters['mcpJsonRpcRequestUio'] == null) {
+            throw new runtime.RequiredError('mcpJsonRpcRequestUio', 'Required parameter "mcpJsonRpcRequestUio" was null or undefined when calling handleBuilderMcpRequest().');
+        }
+        const queryParameters = {};
+        const headerParameters = {};
+        headerParameters['Content-Type'] = 'application/json';
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["X-API-Key"] = await this.configuration.apiKey("X-API-Key"); // ApiKeyAuth authentication
+        }
+        const response = await this.request({
+            path: `/mcp/builder`,
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+            body: (0, index_1.McpJsonRpcRequestUioToJSON)(requestParameters['mcpJsonRpcRequestUio']),
+        }, initOverrides);
+        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.McpJsonRpcResponseUioFromJSON)(jsonValue));
+    }
+    /**
+     * Serveur MCP (Model Context Protocol, transport Streamable HTTP, sans état) qui crée et édite les agents des organisations de l\'utilisateur : de quoi brancher Claude Code, ou tout client MCP, sur la configuration de Breign. Lié à la clé et non à une organisation : chaque outil vérifie que l\'utilisateur est membre de celle qu\'il touche. Distinct du serveur `/organizations/{organizationId}/mcp`, qui ne sert qu\'à interroger les agents : brancher l\'un ne donne pas les droits d\'écriture de l\'autre.  Authentification par clé API personnelle (`x-api-key` ou `Authorization: Bearer ai-…`) ; les credentials d\'app et la clé maître sans `x-user-id` sont refusés. Chaque action est faite au nom du propriétaire de la clé, avec ses droits.  Outils exposés — lecture : - `list_organizations` — organisations dont l\'utilisateur est membre. - `list_agents` `{ organizationId }` — agents de l\'organisation. - `get_agent` `{ agentId }` — configuration d\'un agent : textes, moteur, skills et bases de   connaissance rattachés.  - `list_engines` `{ organizationId }` — providers de l\'organisation et leurs modèles. - `list_skills` `{ organizationId }` — skills de l\'organisation. - `list_knowledge_bases` `{ organizationId }` — bases de connaissance de l\'organisation.  Outils exposés — écriture (jamais de suppression ni de détachement) : - `create_agent` `{ organizationId, name, persona, promptInit?, description?, role?,   defaultLanguage? }`.  - `update_agent` `{ agentId, name?, description?, role?, defaultLanguage?, persona?,   promptInit?, isActivated? }` — `null` ou absent : champ inchangé.  - `set_agent_engine` `{ agentId, providerId, model }`. - `attach_skill` `{ agentId, skillId }` — ajoute un skill, sans retirer les autres. - `attach_knowledge_base` `{ agentId, knowledgeBaseId }` — ajoute une base, sans retirer les   autres.   Un agent Breign dont `builderMcpConfiguration.enabled` est vrai reçoit les mêmes outils, au nom de l\'utilisateur de la conversation, bornés à l\'organisation de l\'agent (ni `list_organizations` ni `organizationId`) ; chaque écriture lui demande alors son approbation.  Configuration d\'un client, par exemple Claude Code : `claude mcp add --transport http breign-builder https://<api>/mcp/builder --header \"Authorization: Bearer ai-…\"`. Le client doit accepter `application/json` et `text/event-stream` (header `Accept`).
+     * Builder MCP server
+     */
+    async handleBuilderMcpRequest(mcpJsonRpcRequestUio, initOverrides) {
+        const response = await this.handleBuilderMcpRequestRaw({ mcpJsonRpcRequestUio: mcpJsonRpcRequestUio }, initOverrides);
+        switch (response.raw.status) {
+            case 200:
+                return await response.value();
+            case 202:
+                return null;
+            default:
+                return await response.value();
+        }
+    }
     /**
      * Serveur MCP (Model Context Protocol, transport Streamable HTTP, sans état) par lequel les agents locaux — Claude Code, Pi, Hermes… — interrogent les agents Breign de l\'organisation.  Authentification par clé API personnelle (`x-api-key` ou `Authorization: Bearer ai-…`) ; les credentials d\'app et la clé maître sans `x-user-id` sont refusés. Seuls les agents dont `mcpExposureConfiguration.enabled` est vrai sont joignables.  Outils exposés : - `list_agents` — agents joignables, avec leur rôle et leur description. - `ask_agent` `{ agentId, message, conversationId?, waitSeconds? }` — pose une question ;   attend la réponse jusqu\'à `waitSeconds` (25 s par défaut, 50 s max), sinon rend un ticket.  - `wait_for_reply` `{ ticket, timeoutSeconds? }` — attend la réponse d\'un ticket (45 s par   défaut, 50 s max).   Chaque question vit dans une conversation de tâche au nom du propriétaire de la clé. L\'agent interrogé peut consulter d\'autres agents ou poser une question à un humain (outil Human_ask) : le statut vaut alors `waiting_human`, parfois pendant des heures.  Configuration d\'un client, par exemple Claude Code : `claude mcp add --transport http breign https://<api>/organizations/<organizationId>/mcp --header \"Authorization: Bearer ai-…\"`. Le client doit accepter `application/json` et `text/event-stream` (header `Accept`).
      * MCP server for local agents

package/dist/models/AgentBuilderMcpConfigurationUio.d.ts

@@ -0,0 +1,32 @@
+/**
+ * brain-client
+ * Api ands models for brain-app and brain-app
+ *
+ * The version of the OpenAPI document: 0.0.0-SNAPSHOT
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+/**
+ * Access to Breign's builder MCP server (create and edit the organisation's agents) from inside a conversation, acting as the user of that conversation. Opt-in; only an organisation admin can change it. Every write the agent makes through it asks the user for approval first.
+ * @export
+ * @interface AgentBuilderMcpConfigurationUio
+ */
+export interface AgentBuilderMcpConfigurationUio {
+    /**
+     * Gives this agent the builder tools.
+     * @type {boolean}
+     * @memberof AgentBuilderMcpConfigurationUio
+     */
+    enabled?: boolean;
+}
+/**
+ * Check if a given object implements the AgentBuilderMcpConfigurationUio interface.
+ */
+export declare function instanceOfAgentBuilderMcpConfigurationUio(value: object): value is AgentBuilderMcpConfigurationUio;
+export declare function AgentBuilderMcpConfigurationUioFromJSON(json: any): AgentBuilderMcpConfigurationUio;
+export declare function AgentBuilderMcpConfigurationUioFromJSONTyped(json: any, ignoreDiscriminator: boolean): AgentBuilderMcpConfigurationUio;
+export declare function AgentBuilderMcpConfigurationUioToJSON(json: any): AgentBuilderMcpConfigurationUio;
+export declare function AgentBuilderMcpConfigurationUioToJSONTyped(value?: AgentBuilderMcpConfigurationUio | null, ignoreDiscriminator?: boolean): any;

package/dist/models/AgentBuilderMcpConfigurationUio.js

@@ -0,0 +1,48 @@
+"use strict";
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * brain-client
+ * Api ands models for brain-app and brain-app
+ *
+ * The version of the OpenAPI document: 0.0.0-SNAPSHOT
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.instanceOfAgentBuilderMcpConfigurationUio = instanceOfAgentBuilderMcpConfigurationUio;
+exports.AgentBuilderMcpConfigurationUioFromJSON = AgentBuilderMcpConfigurationUioFromJSON;
+exports.AgentBuilderMcpConfigurationUioFromJSONTyped = AgentBuilderMcpConfigurationUioFromJSONTyped;
+exports.AgentBuilderMcpConfigurationUioToJSON = AgentBuilderMcpConfigurationUioToJSON;
+exports.AgentBuilderMcpConfigurationUioToJSONTyped = AgentBuilderMcpConfigurationUioToJSONTyped;
+/**
+ * Check if a given object implements the AgentBuilderMcpConfigurationUio interface.
+ */
+function instanceOfAgentBuilderMcpConfigurationUio(value) {
+    return true;
+}
+function AgentBuilderMcpConfigurationUioFromJSON(json) {
+    return AgentBuilderMcpConfigurationUioFromJSONTyped(json, false);
+}
+function AgentBuilderMcpConfigurationUioFromJSONTyped(json, ignoreDiscriminator) {
+    if (json == null) {
+        return json;
+    }
+    return {
+        'enabled': json['enabled'] == null ? undefined : json['enabled'],
+    };
+}
+function AgentBuilderMcpConfigurationUioToJSON(json) {
+    return AgentBuilderMcpConfigurationUioToJSONTyped(json, false);
+}
+function AgentBuilderMcpConfigurationUioToJSONTyped(value, ignoreDiscriminator = false) {
+    if (value == null) {
+        return value;
+    }
+    return {
+        'enabled': value['enabled'],
+    };
+}

package/dist/models/AgentPatchUio.d.ts

@@ -17,6 +17,7 @@ import type { AgentSandboxConfigurationUio } from './AgentSandboxConfigurationUi
 import type { AgentMcpExposureConfigurationUio } from './AgentMcpExposureConfigurationUio';
 import type { AgentSubscriptionUio } from './AgentSubscriptionUio';
 import type { AgentCodeModeConfigurationUio } from './AgentCodeModeConfigurationUio';
+import type { AgentBuilderMcpConfigurationUio } from './AgentBuilderMcpConfigurationUio';
 import type { SpeechToTextConfigUio } from './SpeechToTextConfigUio';
 import type { AgentMemoryConfigurationUio } from './AgentMemoryConfigurationUio';
 import type { AgentPatchEngineUio } from './AgentPatchEngineUio';
@@ -201,6 +202,12 @@ export interface AgentPatchUio {
      * @memberof AgentPatchUio
      */
     mcpExposureConfiguration?: AgentMcpExposureConfigurationUio | null;
+    /**
+     *
+     * @type {AgentBuilderMcpConfigurationUio}
+     * @memberof AgentPatchUio
+     */
+    builderMcpConfiguration?: AgentBuilderMcpConfigurationUio | null;
     /**
      *
      * @type {AgentHumanEscalationConfigurationUio}

package/dist/models/AgentPatchUio.js

@@ -26,6 +26,7 @@ const AgentSandboxConfigurationUio_1 = require("./AgentSandboxConfigurationUio")
 const AgentMcpExposureConfigurationUio_1 = require("./AgentMcpExposureConfigurationUio");
 const AgentSubscriptionUio_1 = require("./AgentSubscriptionUio");
 const AgentCodeModeConfigurationUio_1 = require("./AgentCodeModeConfigurationUio");
+const AgentBuilderMcpConfigurationUio_1 = require("./AgentBuilderMcpConfigurationUio");
 const SpeechToTextConfigUio_1 = require("./SpeechToTextConfigUio");
 const AgentMemoryConfigurationUio_1 = require("./AgentMemoryConfigurationUio");
 const AgentPatchEngineUio_1 = require("./AgentPatchEngineUio");
@@ -74,6 +75,7 @@ function AgentPatchUioFromJSONTyped(json, ignoreDiscriminator) {
         'computerUseConfiguration': json['computerUseConfiguration'] == null ? undefined : (0, AgentComputerUseConfigurationUio_1.AgentComputerUseConfigurationUioFromJSON)(json['computerUseConfiguration']),
         'agentCallConfiguration': json['agentCallConfiguration'] == null ? undefined : (0, AgentCallConfigurationUio_1.AgentCallConfigurationUioFromJSON)(json['agentCallConfiguration']),
         'mcpExposureConfiguration': json['mcpExposureConfiguration'] == null ? undefined : (0, AgentMcpExposureConfigurationUio_1.AgentMcpExposureConfigurationUioFromJSON)(json['mcpExposureConfiguration']),
+        'builderMcpConfiguration': json['builderMcpConfiguration'] == null ? undefined : (0, AgentBuilderMcpConfigurationUio_1.AgentBuilderMcpConfigurationUioFromJSON)(json['builderMcpConfiguration']),
         'humanEscalationConfiguration': json['humanEscalationConfiguration'] == null ? undefined : (0, AgentHumanEscalationConfigurationUio_1.AgentHumanEscalationConfigurationUioFromJSON)(json['humanEscalationConfiguration']),
         'codeModeConfiguration': json['codeModeConfiguration'] == null ? undefined : (0, AgentCodeModeConfigurationUio_1.AgentCodeModeConfigurationUioFromJSON)(json['codeModeConfiguration']),
     };
@@ -114,6 +116,7 @@ function AgentPatchUioToJSONTyped(value, ignoreDiscriminator = false) {
         'computerUseConfiguration': (0, AgentComputerUseConfigurationUio_1.AgentComputerUseConfigurationUioToJSON)(value['computerUseConfiguration']),
         'agentCallConfiguration': (0, AgentCallConfigurationUio_1.AgentCallConfigurationUioToJSON)(value['agentCallConfiguration']),
         'mcpExposureConfiguration': (0, AgentMcpExposureConfigurationUio_1.AgentMcpExposureConfigurationUioToJSON)(value['mcpExposureConfiguration']),
+        'builderMcpConfiguration': (0, AgentBuilderMcpConfigurationUio_1.AgentBuilderMcpConfigurationUioToJSON)(value['builderMcpConfiguration']),
         'humanEscalationConfiguration': (0, AgentHumanEscalationConfigurationUio_1.AgentHumanEscalationConfigurationUioToJSON)(value['humanEscalationConfiguration']),
         'codeModeConfiguration': (0, AgentCodeModeConfigurationUio_1.AgentCodeModeConfigurationUioToJSON)(value['codeModeConfiguration']),
     };

package/dist/models/AgentUio.d.ts

@@ -21,6 +21,7 @@ import type { AgentSubscriptionUio } from './AgentSubscriptionUio';
 import type { AgentToolUio } from './AgentToolUio';
 import type { AgentCodeModeConfigurationUio } from './AgentCodeModeConfigurationUio';
 import type { AgentCreatorUio } from './AgentCreatorUio';
+import type { AgentBuilderMcpConfigurationUio } from './AgentBuilderMcpConfigurationUio';
 import type { SpeechToTextConfigUio } from './SpeechToTextConfigUio';
 import type { AgentMemoryConfigurationUio } from './AgentMemoryConfigurationUio';
 import type { AgentTypeUio } from './AgentTypeUio';
@@ -222,6 +223,12 @@ export interface AgentUio {
      * @memberof AgentUio
      */
     mcpExposureConfiguration?: AgentMcpExposureConfigurationUio | null;
+    /**
+     *
+     * @type {AgentBuilderMcpConfigurationUio}
+     * @memberof AgentUio
+     */
+    builderMcpConfiguration?: AgentBuilderMcpConfigurationUio | null;
     /**
      *
      * @type {AgentHumanEscalationConfigurationUio}

package/dist/models/AgentUio.js

@@ -31,6 +31,7 @@ const AgentSubscriptionUio_1 = require("./AgentSubscriptionUio");
 const AgentToolUio_1 = require("./AgentToolUio");
 const AgentCodeModeConfigurationUio_1 = require("./AgentCodeModeConfigurationUio");
 const AgentCreatorUio_1 = require("./AgentCreatorUio");
+const AgentBuilderMcpConfigurationUio_1 = require("./AgentBuilderMcpConfigurationUio");
 const SpeechToTextConfigUio_1 = require("./SpeechToTextConfigUio");
 const AgentMemoryConfigurationUio_1 = require("./AgentMemoryConfigurationUio");
 const AgentTypeUio_1 = require("./AgentTypeUio");
@@ -107,6 +108,7 @@ function AgentUioFromJSONTyped(json, ignoreDiscriminator) {
         'computerUseConfiguration': json['computerUseConfiguration'] == null ? undefined : (0, AgentComputerUseConfigurationUio_1.AgentComputerUseConfigurationUioFromJSON)(json['computerUseConfiguration']),
         'agentCallConfiguration': json['agentCallConfiguration'] == null ? undefined : (0, AgentCallConfigurationUio_1.AgentCallConfigurationUioFromJSON)(json['agentCallConfiguration']),
         'mcpExposureConfiguration': json['mcpExposureConfiguration'] == null ? undefined : (0, AgentMcpExposureConfigurationUio_1.AgentMcpExposureConfigurationUioFromJSON)(json['mcpExposureConfiguration']),
+        'builderMcpConfiguration': json['builderMcpConfiguration'] == null ? undefined : (0, AgentBuilderMcpConfigurationUio_1.AgentBuilderMcpConfigurationUioFromJSON)(json['builderMcpConfiguration']),
         'humanEscalationConfiguration': json['humanEscalationConfiguration'] == null ? undefined : (0, AgentHumanEscalationConfigurationUio_1.AgentHumanEscalationConfigurationUioFromJSON)(json['humanEscalationConfiguration']),
         'codeModeConfiguration': json['codeModeConfiguration'] == null ? undefined : (0, AgentCodeModeConfigurationUio_1.AgentCodeModeConfigurationUioFromJSON)(json['codeModeConfiguration']),
         'creator': json['creator'] == null ? undefined : (0, AgentCreatorUio_1.AgentCreatorUioFromJSON)(json['creator']),
@@ -155,6 +157,7 @@ function AgentUioToJSONTyped(value, ignoreDiscriminator = false) {
         'computerUseConfiguration': (0, AgentComputerUseConfigurationUio_1.AgentComputerUseConfigurationUioToJSON)(value['computerUseConfiguration']),
         'agentCallConfiguration': (0, AgentCallConfigurationUio_1.AgentCallConfigurationUioToJSON)(value['agentCallConfiguration']),
         'mcpExposureConfiguration': (0, AgentMcpExposureConfigurationUio_1.AgentMcpExposureConfigurationUioToJSON)(value['mcpExposureConfiguration']),
+        'builderMcpConfiguration': (0, AgentBuilderMcpConfigurationUio_1.AgentBuilderMcpConfigurationUioToJSON)(value['builderMcpConfiguration']),
         'humanEscalationConfiguration': (0, AgentHumanEscalationConfigurationUio_1.AgentHumanEscalationConfigurationUioToJSON)(value['humanEscalationConfiguration']),
         'codeModeConfiguration': (0, AgentCodeModeConfigurationUio_1.AgentCodeModeConfigurationUioToJSON)(value['codeModeConfiguration']),
         'creator': (0, AgentCreatorUio_1.AgentCreatorUioToJSON)(value['creator']),

package/dist/models/ToolAllowedToolsRequestUio.d.ts

@@ -21,7 +21,23 @@ export interface ToolAllowedToolsRequestUio {
      * @memberof ToolAllowedToolsRequestUio
      */
     allowedTools: Set<string>;
+    /**
+     * Quand un appel de l'outil demande l'approbation de l'utilisateur, par nom d'outil. Absent : automatique — demandée sauf si le serveur déclare l'outil en lecture seule (readOnlyHint). always : toujours demander, et refuser l'appel quand personne ne peut répondre (tâche planifiée, widget, appel entre agents). never : ne jamais demander.
+     * @type {{ [key: string]: string; }}
+     * @memberof ToolAllowedToolsRequestUio
+     */
+    approvalModes?: {
+        [key: string]: string;
+    };
 }
+/**
+ * @export
+ */
+export declare const ToolAllowedToolsRequestUioApprovalModesEnum: {
+    readonly Always: "always";
+    readonly Never: "never";
+};
+export type ToolAllowedToolsRequestUioApprovalModesEnum = typeof ToolAllowedToolsRequestUioApprovalModesEnum[keyof typeof ToolAllowedToolsRequestUioApprovalModesEnum];
 /**
  * Check if a given object implements the ToolAllowedToolsRequestUio interface.
  */

package/dist/models/ToolAllowedToolsRequestUio.js

@@ -13,11 +13,19 @@
  * Do not edit the class manually.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.ToolAllowedToolsRequestUioApprovalModesEnum = void 0;
 exports.instanceOfToolAllowedToolsRequestUio = instanceOfToolAllowedToolsRequestUio;
 exports.ToolAllowedToolsRequestUioFromJSON = ToolAllowedToolsRequestUioFromJSON;
 exports.ToolAllowedToolsRequestUioFromJSONTyped = ToolAllowedToolsRequestUioFromJSONTyped;
 exports.ToolAllowedToolsRequestUioToJSON = ToolAllowedToolsRequestUioToJSON;
 exports.ToolAllowedToolsRequestUioToJSONTyped = ToolAllowedToolsRequestUioToJSONTyped;
+/**
+ * @export
+ */
+exports.ToolAllowedToolsRequestUioApprovalModesEnum = {
+    Always: 'always',
+    Never: 'never'
+};
 /**
  * Check if a given object implements the ToolAllowedToolsRequestUio interface.
  */
@@ -35,6 +43,7 @@ function ToolAllowedToolsRequestUioFromJSONTyped(json, ignoreDiscriminator) {
     }
     return {
         'allowedTools': new Set(json['allowedTools']),
+        'approvalModes': json['approvalModes'] == null ? undefined : json['approvalModes'],
     };
 }
 function ToolAllowedToolsRequestUioToJSON(json) {
@@ -46,5 +55,6 @@ function ToolAllowedToolsRequestUioToJSONTyped(value, ignoreDiscriminator = fals
     }
     return {
         'allowedTools': Array.from(value['allowedTools']),
+        'approvalModes': value['approvalModes'],
     };
 }

package/dist/models/ToolAllowedToolsResponseUio.d.ts

@@ -21,7 +21,23 @@ export interface ToolAllowedToolsResponseUio {
      * @memberof ToolAllowedToolsResponseUio
      */
     allowedTools: Array<string>;
+    /**
+     * Quand un appel de l'outil demande l'approbation de l'utilisateur, par nom d'outil. Absent : automatique — demandée sauf si le serveur déclare l'outil en lecture seule (readOnlyHint). always : toujours demander, et refuser l'appel quand personne ne peut répondre (tâche planifiée, widget, appel entre agents). never : ne jamais demander.
+     * @type {{ [key: string]: string; }}
+     * @memberof ToolAllowedToolsResponseUio
+     */
+    approvalModes?: {
+        [key: string]: string;
+    };
 }
+/**
+ * @export
+ */
+export declare const ToolAllowedToolsResponseUioApprovalModesEnum: {
+    readonly Always: "always";
+    readonly Never: "never";
+};
+export type ToolAllowedToolsResponseUioApprovalModesEnum = typeof ToolAllowedToolsResponseUioApprovalModesEnum[keyof typeof ToolAllowedToolsResponseUioApprovalModesEnum];
 /**
  * Check if a given object implements the ToolAllowedToolsResponseUio interface.
  */

package/dist/models/ToolAllowedToolsResponseUio.js

@@ -13,11 +13,19 @@
  * Do not edit the class manually.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.ToolAllowedToolsResponseUioApprovalModesEnum = void 0;
 exports.instanceOfToolAllowedToolsResponseUio = instanceOfToolAllowedToolsResponseUio;
 exports.ToolAllowedToolsResponseUioFromJSON = ToolAllowedToolsResponseUioFromJSON;
 exports.ToolAllowedToolsResponseUioFromJSONTyped = ToolAllowedToolsResponseUioFromJSONTyped;
 exports.ToolAllowedToolsResponseUioToJSON = ToolAllowedToolsResponseUioToJSON;
 exports.ToolAllowedToolsResponseUioToJSONTyped = ToolAllowedToolsResponseUioToJSONTyped;
+/**
+ * @export
+ */
+exports.ToolAllowedToolsResponseUioApprovalModesEnum = {
+    Always: 'always',
+    Never: 'never'
+};
 /**
  * Check if a given object implements the ToolAllowedToolsResponseUio interface.
  */
@@ -35,6 +43,7 @@ function ToolAllowedToolsResponseUioFromJSONTyped(json, ignoreDiscriminator) {
     }
     return {
         'allowedTools': json['allowedTools'],
+        'approvalModes': json['approvalModes'] == null ? undefined : json['approvalModes'],
     };
 }
 function ToolAllowedToolsResponseUioToJSON(json) {
@@ -46,5 +55,6 @@ function ToolAllowedToolsResponseUioToJSONTyped(value, ignoreDiscriminator = fal
     }
     return {
         'allowedTools': value['allowedTools'],
+        'approvalModes': value['approvalModes'],
     };
 }

package/dist/models/ToolApprovalUio.d.ts

@@ -34,7 +34,7 @@ export interface ToolApprovalUio {
      */
     toolName: string;
     /**
-     * Which family the approval belongs to. url is an address the agent sandbox may reach; urlPattern is a glob covering a whole site, subdomains included; command is one exact command line it may run.
+     * Which family the approval belongs to. url is an address the agent sandbox may reach; urlPattern is a glob covering a whole site, subdomains included; command is one exact command line it may run; mcpTool is an MCP tool that writes, as server/tool (for example builder/update_agent), whatever its arguments — stored under toolName mcp. An mcpTool approval is only ever born of a question the agent asked: it cannot be created or edited by hand.
      * @type {string}
      * @memberof ToolApprovalUio
      */
@@ -73,6 +73,7 @@ export declare const ToolApprovalUioResourceKindEnum: {
     readonly Url: "url";
     readonly Command: "command";
     readonly UrlPattern: "urlPattern";
+    readonly McpTool: "mcpTool";
 };
 export type ToolApprovalUioResourceKindEnum = typeof ToolApprovalUioResourceKindEnum[keyof typeof ToolApprovalUioResourceKindEnum];
 /**

package/dist/models/ToolApprovalUio.js

@@ -32,7 +32,8 @@ exports.ToolApprovalUioScopeKindEnum = {
 exports.ToolApprovalUioResourceKindEnum = {
     Url: 'url',
     Command: 'command',
-    UrlPattern: 'urlPattern'
+    UrlPattern: 'urlPattern',
+    McpTool: 'mcpTool'
 };
 /**
  * Check if a given object implements the ToolApprovalUio interface.

package/dist/models/ToolCallResultRequestUio.d.ts

@@ -41,7 +41,7 @@ export interface ToolCallResultRequestUio {
      */
     error?: string;
     /**
-     * Only read when resolving a bash_network_approval or bash_command_approval call with status completed: how far the approval reaches. once — the suspended reply and nothing after it, so the same request is asked about again next time — is the default, and nothing is stored. agentUser covers this agent, for this user, across all of their conversations, and is kept until revoked. Any other value is refused with a 400. Never widens what the agent is allowed to do: the server-side lock and the per-agent switch remain prerequisites. Only the user the question was asked of may answer it: an approval is a personal consent, so another caller — an admin included — gets a 403.
+     * Only read when resolving a bash_network_approval, bash_command_approval or mcp_tool_approval call with status completed: how far the approval reaches. once — the suspended reply and nothing after it, so the same request is asked about again next time — is the default, and nothing is stored. agentUser covers this agent, for this user, across all of their conversations, and is kept until revoked. Any other value is refused with a 400. Never widens what the agent is allowed to do: the server-side lock and the per-agent switch remain prerequisites. Only the user the question was asked of may answer it: an approval is a personal consent, so another caller — an admin included — gets a 403.
      * @type {string}
      * @memberof ToolCallResultRequestUio
      */

package/dist/models/ToolCallUio.d.ts

@@ -22,7 +22,7 @@ export interface ToolCallUio {
      */
     callId: string;
     /**
-     * Name of the tool the model called. Three values are produced by the server today. take_screenshot asks the client to capture the screen. bash_network_approval is an agent sandbox asking permission to reach an address: arguments carries url (the full address, to be shown as-is), urlPrefix (what a yes actually grants), origin, host and method. bash_command_approval is an agent sandbox asking permission to run a command through one of its interpreters — python3 or js-exec: arguments carries command, which is both what has to be shown in full and exactly what a yes grants — nothing ran, so a refusal leaves the sandbox untouched. Calls named bash_python_approval, the name this last one carried while python was the only interpreter, may still be waiting in older conversations and resolve exactly the same way.
+     * Name of the tool the model called. Four values are produced by the server today. mcp_tool_approval asks permission to run an MCP tool: a write of the builder server, which creates and edits agents, or a tool of an MCP server configured in the organisation, by its approval mode (see Tool.mcp.approvalModes). arguments carries server (builder, or the id of the organisation's tool), serverName (the name to show), tool and arguments (the exact call the model wants to make), and — builder only — preview — what the call changes, for display only: tool, agentName, changes (field, before when something existed, after, with names instead of ids, unchanged fields left out) and warnings (deactivates, rewritesInstructions, changesEngine); null when it could not be built. Allow once covers exactly these arguments; agentUser covers the tool whatever its arguments. take_screenshot asks the client to capture the screen. bash_network_approval is an agent sandbox asking permission to reach an address: arguments carries url (the full address, to be shown as-is), urlPrefix (what a yes actually grants), origin, host and method. bash_command_approval is an agent sandbox asking permission to run a command through one of its interpreters — python3 or js-exec: arguments carries command, which is both what has to be shown in full and exactly what a yes grants — nothing ran, so a refusal leaves the sandbox untouched. Calls named bash_python_approval, the name this last one carried while python was the only interpreter, may still be waiting in older conversations and resolve exactly the same way.
      * @type {string}
      * @memberof ToolCallUio
      */

package/dist/models/ToolSecureMcpUio.d.ts

@@ -35,7 +35,23 @@ export interface ToolSecureMcpUio {
      * @memberof ToolSecureMcpUio
      */
     allowedTools?: Array<string>;
+    /**
+     * Quand un appel de l'outil demande l'approbation de l'utilisateur, par nom d'outil. Absent : automatique — demandée sauf si le serveur déclare l'outil en lecture seule (readOnlyHint). always : toujours demander, et refuser l'appel quand personne ne peut répondre (tâche planifiée, widget, appel entre agents). never : ne jamais demander.
+     * @type {{ [key: string]: string; }}
+     * @memberof ToolSecureMcpUio
+     */
+    approvalModes?: {
+        [key: string]: string;
+    };
 }
+/**
+ * @export
+ */
+export declare const ToolSecureMcpUioApprovalModesEnum: {
+    readonly Always: "always";
+    readonly Never: "never";
+};
+export type ToolSecureMcpUioApprovalModesEnum = typeof ToolSecureMcpUioApprovalModesEnum[keyof typeof ToolSecureMcpUioApprovalModesEnum];
 /**
  * Check if a given object implements the ToolSecureMcpUio interface.
  */

package/dist/models/ToolSecureMcpUio.js

@@ -13,12 +13,20 @@
  * Do not edit the class manually.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.ToolSecureMcpUioApprovalModesEnum = void 0;
 exports.instanceOfToolSecureMcpUio = instanceOfToolSecureMcpUio;
 exports.ToolSecureMcpUioFromJSON = ToolSecureMcpUioFromJSON;
 exports.ToolSecureMcpUioFromJSONTyped = ToolSecureMcpUioFromJSONTyped;
 exports.ToolSecureMcpUioToJSON = ToolSecureMcpUioToJSON;
 exports.ToolSecureMcpUioToJSONTyped = ToolSecureMcpUioToJSONTyped;
 const ToolSecureMcpDefinitionUio_1 = require("./ToolSecureMcpDefinitionUio");
+/**
+ * @export
+ */
+exports.ToolSecureMcpUioApprovalModesEnum = {
+    Always: 'always',
+    Never: 'never'
+};
 /**
  * Check if a given object implements the ToolSecureMcpUio interface.
  */
@@ -37,6 +45,7 @@ function ToolSecureMcpUioFromJSONTyped(json, ignoreDiscriminator) {
         'definition': json['definition'] == null ? undefined : (0, ToolSecureMcpDefinitionUio_1.ToolSecureMcpDefinitionUioFromJSON)(json['definition']),
         'introspection': json['introspection'] == null ? undefined : json['introspection'],
         'allowedTools': json['allowedTools'] == null ? undefined : json['allowedTools'],
+        'approvalModes': json['approvalModes'] == null ? undefined : json['approvalModes'],
     };
 }
 function ToolSecureMcpUioToJSON(json) {
@@ -51,5 +60,6 @@ function ToolSecureMcpUioToJSONTyped(value, ignoreDiscriminator = false) {
         'definition': (0, ToolSecureMcpDefinitionUio_1.ToolSecureMcpDefinitionUioToJSON)(value['definition']),
         'introspection': value['introspection'],
         'allowedTools': value['allowedTools'],
+        'approvalModes': value['approvalModes'],
     };
 }

package/dist/models/index.d.ts

@@ -18,6 +18,7 @@ export * from './AdvancedFlowEditorNodeUio';
 export * from './AdvancedFlowEditorUio';
 export * from './AdvancedFlowEditorUpdateRequestUio';
 export * from './AgentAssignmentUio';
+export * from './AgentBuilderMcpConfigurationUio';
 export * from './AgentBundleDiffUio';
 export * from './AgentBundleListDiffUio';
 export * from './AgentCallConfigurationUio';

package/dist/models/index.js

@@ -36,6 +36,7 @@ __exportStar(require("./AdvancedFlowEditorNodeUio"), exports);
 __exportStar(require("./AdvancedFlowEditorUio"), exports);
 __exportStar(require("./AdvancedFlowEditorUpdateRequestUio"), exports);
 __exportStar(require("./AgentAssignmentUio"), exports);
+__exportStar(require("./AgentBuilderMcpConfigurationUio"), exports);
 __exportStar(require("./AgentBundleDiffUio"), exports);
 __exportStar(require("./AgentBundleListDiffUio"), exports);
 __exportStar(require("./AgentCallConfigurationUio"), exports);

package/dist/openapi.json

@@ -6154,6 +6154,85 @@
         "tags" : [ "mcp" ]
       }
     },
+    "/mcp/builder" : {
+      "delete" : {
+        "description" : "Aucune session à clore : le transport est sans état.",
+        "operationId" : "deleteBuilderMcpSession",
+        "responses" : {
+          "405" : {
+            "content" : {
+              "application/json" : {
+                "schema" : {
+                  "$ref" : "#/components/schemas/McpJsonRpcResponse"
+                }
+              }
+            },
+            "description" : "Method not allowed"
+          }
+        },
+        "summary" : "Not supported (stateless MCP server)",
+        "tags" : [ "mcp" ]
+      },
+      "get" : {
+        "description" : "Pas de flux SSE côté serveur : le transport est sans état.",
+        "operationId" : "getBuilderMcpStream",
+        "responses" : {
+          "405" : {
+            "content" : {
+              "application/json" : {
+                "schema" : {
+                  "$ref" : "#/components/schemas/McpJsonRpcResponse"
+                }
+              }
+            },
+            "description" : "Method not allowed"
+          }
+        },
+        "summary" : "Not supported (stateless MCP server)",
+        "tags" : [ "mcp" ]
+      },
+      "post" : {
+        "description" : "Serveur MCP (Model Context Protocol, transport Streamable HTTP, sans état) qui crée et édite les agents des organisations de l'utilisateur : de quoi brancher Claude Code, ou tout client MCP, sur la configuration de Breign. Lié à la clé et non à une organisation : chaque outil vérifie que l'utilisateur est membre de celle qu'il touche. Distinct du serveur `/organizations/{organizationId}/mcp`, qui ne sert qu'à interroger les agents : brancher l'un ne donne pas les droits d'écriture de l'autre.\n\nAuthentification par clé API personnelle (`x-api-key` ou `Authorization: Bearer ai-…`) ; les credentials d'app et la clé maître sans `x-user-id` sont refusés. Chaque action est faite au nom du propriétaire de la clé, avec ses droits.\n\nOutils exposés — lecture :\n- `list_organizations` — organisations dont l'utilisateur est membre.\n- `list_agents` `{ organizationId }` — agents de l'organisation.\n- `get_agent` `{ agentId }` — configuration d'un agent : textes, moteur, skills et bases de\n  connaissance rattachés.\n\n- `list_engines` `{ organizationId }` — providers de l'organisation et leurs modèles.\n- `list_skills` `{ organizationId }` — skills de l'organisation.\n- `list_knowledge_bases` `{ organizationId }` — bases de connaissance de l'organisation.\n\nOutils exposés — écriture (jamais de suppression ni de détachement) :\n- `create_agent` `{ organizationId, name, persona, promptInit?, description?, role?,\n  defaultLanguage? }`.\n\n- `update_agent` `{ agentId, name?, description?, role?, defaultLanguage?, persona?,\n  promptInit?, isActivated? }` — `null` ou absent : champ inchangé.\n\n- `set_agent_engine` `{ agentId, providerId, model }`.\n- `attach_skill` `{ agentId, skillId }` — ajoute un skill, sans retirer les autres.\n- `attach_knowledge_base` `{ agentId, knowledgeBaseId }` — ajoute une base, sans retirer les\n  autres.\n\n\nUn agent Breign dont `builderMcpConfiguration.enabled` est vrai reçoit les mêmes outils, au nom de l'utilisateur de la conversation, bornés à l'organisation de l'agent (ni `list_organizations` ni `organizationId`) ; chaque écriture lui demande alors son approbation.\n\nConfiguration d'un client, par exemple Claude Code : `claude mcp add --transport http breign-builder https://<api>/mcp/builder --header \"Authorization: Bearer ai-…\"`. Le client doit accepter `application/json` et `text/event-stream` (header `Accept`).",
+        "operationId" : "handleBuilderMcpRequest",
+        "requestBody" : {
+          "content" : {
+            "application/json" : {
+              "schema" : {
+                "$ref" : "#/components/schemas/McpJsonRpcRequest"
+              }
+            }
+          },
+          "required" : true
+        },
+        "responses" : {
+          "200" : {
+            "content" : {
+              "application/json" : {
+                "schema" : {
+                  "$ref" : "#/components/schemas/McpJsonRpcResponse"
+                }
+              }
+            },
+            "description" : "Réponse JSON-RPC"
+          },
+          "202" : {
+            "description" : "Notification acceptée, sans corps"
+          },
+          "401" : {
+            "content" : {
+              "application/json" : {
+                "schema" : {
+                  "$ref" : "#/components/schemas/McpJsonRpcResponse"
+                }
+              }
+            },
+            "description" : "Clé API personnelle requise"
+          }
+        },
+        "summary" : "Builder MCP server",
+        "tags" : [ "mcp" ]
+      }
+    },
     "/conversations/{conversationId}/read" : {
       "post" : {
         "description" : "Positionne la marque de lecture de l'utilisateur sur la conversation.",
@@ -21282,6 +21361,12 @@
             } ],
             "nullable" : true
           },
+          "builderMcpConfiguration" : {
+            "allOf" : [ {
+              "$ref" : "#/components/schemas/AgentBuilderMcpConfiguration"
+            } ],
+            "nullable" : true
+          },
           "humanEscalationConfiguration" : {
             "allOf" : [ {
               "$ref" : "#/components/schemas/AgentHumanEscalationConfiguration"
@@ -21528,6 +21613,16 @@
         },
         "type" : "object"
       },
+      "AgentBuilderMcpConfiguration" : {
+        "description" : "Access to Breign's builder MCP server (create and edit the organisation's agents) from inside a conversation, acting as the user of that conversation. Opt-in; only an organisation admin can change it. Every write the agent makes through it asks the user for approval first.",
+        "properties" : {
+          "enabled" : {
+            "description" : "Gives this agent the builder tools.",
+            "type" : "boolean"
+          }
+        },
+        "type" : "object"
+      },
       "AgentHumanEscalationConfiguration" : {
         "description" : "Per-agent activation of the Human_ask tool, offered only in task conversations (a local agent or another agent asking). The question goes to the first valid referent; without one, to the user who owns the task — the person who connected the local agent.",
         "properties" : {
@@ -21760,6 +21855,12 @@
             } ],
             "nullable" : true
           },
+          "builderMcpConfiguration" : {
+            "allOf" : [ {
+              "$ref" : "#/components/schemas/AgentBuilderMcpConfiguration"
+            } ],
+            "nullable" : true
+          },
           "humanEscalationConfiguration" : {
             "allOf" : [ {
               "$ref" : "#/components/schemas/AgentHumanEscalationConfiguration"
@@ -26908,8 +27009,8 @@
             "type" : "string"
           },
           "resourceKind" : {
-            "description" : "Which family the approval belongs to. url is an address the agent sandbox may reach; urlPattern is a glob covering a whole site, subdomains included; command is one exact command line it may run.",
-            "enum" : [ "url", "command", "urlPattern" ],
+            "description" : "Which family the approval belongs to. url is an address the agent sandbox may reach; urlPattern is a glob covering a whole site, subdomains included; command is one exact command line it may run; mcpTool is an MCP tool that writes, as server/tool (for example builder/update_agent), whatever its arguments — stored under toolName mcp. An mcpTool approval is only ever born of a question the agent asked: it cannot be created or edited by hand.",
+            "enum" : [ "url", "command", "urlPattern", "mcpTool" ],
             "type" : "string"
           },
           "resource" : {
@@ -27629,6 +27730,14 @@
             },
             "type" : "array",
             "uniqueItems" : true
+          },
+          "approvalModes" : {
+            "additionalProperties" : {
+              "enum" : [ "always", "never" ],
+              "type" : "string"
+            },
+            "description" : "Quand un appel de l'outil demande l'approbation de l'utilisateur, par nom d'outil. Absent : automatique — demandée sauf si le serveur déclare l'outil en lecture seule (readOnlyHint). always : toujours demander, et refuser l'appel quand personne ne peut répondre (tâche planifiée, widget, appel entre agents). never : ne jamais demander.",
+            "type" : "object"
           }
         },
         "required" : [ "allowedTools" ],
@@ -27643,6 +27752,14 @@
               "type" : "string"
             },
             "type" : "array"
+          },
+          "approvalModes" : {
+            "additionalProperties" : {
+              "enum" : [ "always", "never" ],
+              "type" : "string"
+            },
+            "description" : "Quand un appel de l'outil demande l'approbation de l'utilisateur, par nom d'outil. Absent : automatique — demandée sauf si le serveur déclare l'outil en lecture seule (readOnlyHint). always : toujours demander, et refuser l'appel quand personne ne peut répondre (tâche planifiée, widget, appel entre agents). never : ne jamais demander.",
+            "type" : "object"
           }
         },
         "required" : [ "allowedTools" ],
@@ -29066,7 +29183,7 @@
             "type" : "string"
           },
           "tool" : {
-            "description" : "Name of the tool the model called. Three values are produced by the server today. take_screenshot asks the client to capture the screen. bash_network_approval is an agent sandbox asking permission to reach an address: arguments carries url (the full address, to be shown as-is), urlPrefix (what a yes actually grants), origin, host and method. bash_command_approval is an agent sandbox asking permission to run a command through one of its interpreters — python3 or js-exec: arguments carries command, which is both what has to be shown in full and exactly what a yes grants — nothing ran, so a refusal leaves the sandbox untouched. Calls named bash_python_approval, the name this last one carried while python was the only interpreter, may still be waiting in older conversations and resolve exactly the same way.",
+            "description" : "Name of the tool the model called. Four values are produced by the server today. mcp_tool_approval asks permission to run an MCP tool: a write of the builder server, which creates and edits agents, or a tool of an MCP server configured in the organisation, by its approval mode (see Tool.mcp.approvalModes). arguments carries server (builder, or the id of the organisation's tool), serverName (the name to show), tool and arguments (the exact call the model wants to make), and — builder only — preview — what the call changes, for display only: tool, agentName, changes (field, before when something existed, after, with names instead of ids, unchanged fields left out) and warnings (deactivates, rewritesInstructions, changesEngine); null when it could not be built. Allow once covers exactly these arguments; agentUser covers the tool whatever its arguments. take_screenshot asks the client to capture the screen. bash_network_approval is an agent sandbox asking permission to reach an address: arguments carries url (the full address, to be shown as-is), urlPrefix (what a yes actually grants), origin, host and method. bash_command_approval is an agent sandbox asking permission to run a command through one of its interpreters — python3 or js-exec: arguments carries command, which is both what has to be shown in full and exactly what a yes grants — nothing ran, so a refusal leaves the sandbox untouched. Calls named bash_python_approval, the name this last one carried while python was the only interpreter, may still be waiting in older conversations and resolve exactly the same way.",
             "type" : "string"
           },
           "status" : {
@@ -29129,7 +29246,7 @@
             "type" : "string"
           },
           "approvalScope" : {
-            "description" : "Only read when resolving a bash_network_approval or bash_command_approval call with status completed: how far the approval reaches. once — the suspended reply and nothing after it, so the same request is asked about again next time — is the default, and nothing is stored. agentUser covers this agent, for this user, across all of their conversations, and is kept until revoked. Any other value is refused with a 400. Never widens what the agent is allowed to do: the server-side lock and the per-agent switch remain prerequisites. Only the user the question was asked of may answer it: an approval is a personal consent, so another caller — an admin included — gets a 403.",
+            "description" : "Only read when resolving a bash_network_approval, bash_command_approval or mcp_tool_approval call with status completed: how far the approval reaches. once — the suspended reply and nothing after it, so the same request is asked about again next time — is the default, and nothing is stored. agentUser covers this agent, for this user, across all of their conversations, and is kept until revoked. Any other value is refused with a 400. Never widens what the agent is allowed to do: the server-side lock and the per-agent switch remain prerequisites. Only the user the question was asked of may answer it: an approval is a personal consent, so another caller — an admin included — gets a 403.",
             "enum" : [ "once", "agentUser" ],
             "type" : "string"
           },
@@ -34689,6 +34806,14 @@
               "type" : "string"
             },
             "type" : "array"
+          },
+          "approvalModes" : {
+            "additionalProperties" : {
+              "enum" : [ "always", "never" ],
+              "type" : "string"
+            },
+            "description" : "Quand un appel de l'outil demande l'approbation de l'utilisateur, par nom d'outil. Absent : automatique — demandée sauf si le serveur déclare l'outil en lecture seule (readOnlyHint). always : toujours demander, et refuser l'appel quand personne ne peut répondre (tâche planifiée, widget, appel entre agents). never : ne jamais demander.",
+            "type" : "object"
           }
         },
         "type" : "object"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@breign/client",
-  "version": "1.0.177",
+  "version": "1.0.178",
   "main": "dist/index.js",
   "exports": {
     ".": "./dist/index.js",