blomios/IdeA
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat(backend): MCP d'édition de templates (#81)

Browse Source 
Ajoute le MCP dédié à l'édition de templates : catalogue et classification
des templates (mcp/templates.rs infrastructure + app-tauri), use cases et
provider (application/template), enforcement de la policy des tools (mod.rs,
server.rs, tools.rs), avec la parité côté chemin OpenAI-compatible
(openai_tools.rs x2).

Lots B1 (catalogue/classification), B2 (use cases/provider) et B3
(enforcement policy) livrés en un seul commit cohérent.

QA vert (seul l'échec de bind loopback #80, connu et non-régression, écarté).

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
This commit is contained in:
Blomios
2026-07-20 18:45:02 +02:00
parent 448edfc364
commit ef84d5cc49
17 changed files with 1171 additions and 49 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
crates/backend/src/dto.rs
View File

@ -2444,8 +2444,8 @@ impl From<ListResumableAgentsOutput> for ResumableAgentListDto {
use application::{
AgentDrift, CreateAgentFromTemplateInput, CreateTemplateInput, CreateTemplateOutput,
DetectAgentDriftOutput, ListTemplatesOutput, SyncAgentWithTemplateOutput, UpdateTemplateInput,
UpdateTemplateOutput,
DetectAgentDriftOutput, ListTemplatesOutput, ReadTemplateOutput, SyncAgentWithTemplateOutput,
UpdateTemplateInput, UpdateTemplateOutput,
};
use domain::{AgentTemplate, TemplateId};
@ -2473,6 +2473,12 @@ impl From<CreateTemplateOutput> for TemplateDto {
}
}
impl From<ReadTemplateOutput> for TemplateDto {
fn from(out: ReadTemplateOutput) -> Self {
Self(out.template)
}
}
impl From<UpdateTemplateOutput> for TemplateDto {
fn from(out: UpdateTemplateOutput) -> Self {
Self(out.template)

75
crates/backend/src/lib.rs
View File

@ -32,7 +32,7 @@ use application::{
OpenTerminal, OpenTicketAssistant, OrchestratorService, PairAttemptLimiter, PairDevice,
PermissionProjectorRegistry, ProposeContext, ReadAgentContext, ReadContext,
ReadConversationPage, ReadIssue, ReadIssueCarnet, ReadMcpToolPermissions, ReadMemory,
ReadMemoryIndex, ReadProjectContext, ReadSkill, RecallMemory, ReconcileLayouts,
ReadMemoryIndex, ReadProjectContext, ReadSkill, ReadTemplate, RecallMemory, ReconcileLayouts,
ReconcileLiveState, ReconcileLiveStateInput, RecordTurn, RecordTurnProvider, ReferenceProfiles,
RenameDevice, RenameLayout, RenameSprint, ReorderSprints, ResizeTerminal,
ResolveAgentPermissions, ResolveMemoryLinks, RestoreOpenWindows, RetryBackgroundTask,
@ -83,9 +83,10 @@ use infrastructure::{
InMemoryPairAttemptLimiter, LlamaCppRuntime, LocalFileSystem, LocalManagedProcess,
LocalProcessSpawner, McpServer, MediatedInbox, NaiveMemoryRecall, OrchestratorWatchHandle,
PortablePtyAdapter, RwFileGuard, StructuredSessionFactory, SystemClock, SystemMillisClock,
TicketAssistantEnvironmentPreparer, TicketToolProvider, TokioBroadcastEventBus, TokioScheduler,
ToolPolicyRegistry, UuidGenerator, VectorMemoryRecall, DEFAULT_OLLAMA_BASE_URL,
ONNX_CACHE_SUBDIR, RECOMMENDED_ONNX_MODELS, VECTOR_HTTP_ENABLED, VECTOR_ONNX_ENABLED,
TemplateToolProvider, TicketAssistantEnvironmentPreparer, TicketToolProvider,
TokioBroadcastEventBus, TokioScheduler, ToolPolicyRegistry, UuidGenerator, VectorMemoryRecall,
DEFAULT_OLLAMA_BASE_URL, ONNX_CACHE_SUBDIR, RECOMMENDED_ONNX_MODELS, VECTOR_HTTP_ENABLED,
VECTOR_ONNX_ENABLED,
};
pub mod dto;
@ -174,6 +175,48 @@ impl TicketToolProvider for LateBoundTicketToolProvider {
}
}
#[derive(Clone, Default)]
pub struct LateBoundTemplateToolProvider {
inner: Arc<Mutex<Option<Arc<dyn TemplateToolProvider>>>>,
}
impl LateBoundTemplateToolProvider {
#[must_use]
pub fn new() -> Self {
Self::default()
}
pub fn bind(&self, inner: Arc<dyn TemplateToolProvider>) {
*self.inner.lock().expect("template tool mutex poisoned") = Some(inner);
}
}
#[async_trait]
impl TemplateToolProvider for LateBoundTemplateToolProvider {
async fn handle_template_tool(
&self,
project: &Project,
requester: &str,
name: &str,
arguments: Value,
) -> Result<Value, infrastructure::TemplateToolError> {
let inner = self
.inner
.lock()
.expect("template tool mutex poisoned")
.clone()
.ok_or_else(|| {
infrastructure::TemplateToolError::new(
"UNAVAILABLE",
"template tool provider not bound".to_owned(),
)
})?;
inner
.handle_template_tool(project, requester, name, arguments)
.await
}
}
/// Implémente [`RecordTurnProvider`] (lot P6b) en matérialisant un [`RecordTurn`]
/// ciblant le **project root** du tour en cours.
///
@ -937,6 +980,8 @@ pub struct BackendCore {
pub unassign_ticket_from_sprint: Arc<UnassignTicketFromSprint>,
/// MCP provider for the public `idea_ticket_*` tools.
pub(crate) ticket_tool_provider: Arc<dyn TicketToolProvider>,
/// MCP provider for the public `idea_template_*` tools.
pub(crate) template_tool_provider: Arc<dyn TemplateToolProvider>,
/// Open an ephemeral AI assistant chat bound to one ticket.
pub open_ticket_assistant: Arc<OpenTicketAssistant>,
/// Close an ephemeral AI assistant chat bound to one ticket.
@ -1017,6 +1062,8 @@ pub struct BackendCore {
// --- Templates & sync (L7) ---
/// Create a template in the global store.
pub create_template: Arc<CreateTemplate>,
/// Read a template in the global store.
pub read_template: Arc<ReadTemplate>,
/// Update a template's content (bumps version).
pub update_template: Arc<UpdateTemplate>,
/// List all templates in the global store.
@ -1138,6 +1185,8 @@ pub struct BackendCore {
pub home_dir: String,
/// Late-bound concrete ticket MCP provider supplied by the driving adapter.
pub ticket_tool_binder: Arc<LateBoundTicketToolProvider>,
/// Late-bound concrete template MCP provider supplied by the driving adapter.
pub template_tool_binder: Arc<LateBoundTemplateToolProvider>,
}
impl BackendCore {
@ -1474,6 +1523,8 @@ impl BackendCore {
));
let ticket_tool_binder = Arc::new(LateBoundTicketToolProvider::new());
let ticket_tool_provider: Arc<dyn TicketToolProvider> = ticket_tool_binder.clone();
let template_tool_binder = Arc::new(LateBoundTemplateToolProvider::new());
let template_tool_provider: Arc<dyn TemplateToolProvider> = template_tool_binder.clone();
let tool_policy_registry = Arc::new(ToolPolicyRegistry::new());
let tool_policy_store = Arc::clone(&tool_policy_registry) as Arc<dyn AgentToolPolicyStore>;
let assistant_context_provider = Arc::new(FsAssistantContextStore::new(
@ -1841,6 +1892,7 @@ impl BackendCore {
Arc::clone(&template_store_port),
Arc::clone(&ids) as Arc<dyn IdGenerator>,
));
let read_template = Arc::new(ReadTemplate::new(Arc::clone(&template_store_port)));
let update_template = Arc::new(UpdateTemplate::new(
Arc::clone(&template_store_port),
Arc::clone(&events_port),
@ -2384,6 +2436,7 @@ impl BackendCore {
Arc::clone(&tool_policy_registry) as Arc<dyn AgentToolPolicyStore>,
Arc::clone(&mcp_tool_permission_store_port),
Arc::clone(&ticket_tool_provider),
Arc::clone(&template_tool_provider),
)) as Arc<dyn ToolInvoker>);
let stop_live_agent = Arc::new(
@ -2472,6 +2525,7 @@ impl BackendCore {
assign_ticket_to_sprint,
unassign_ticket_from_sprint,
ticket_tool_provider,
template_tool_provider,
open_ticket_assistant,
close_ticket_assistant,
tool_policy_registry,
@ -2500,6 +2554,7 @@ impl BackendCore {
update_agent_permissions,
resolve_agent_permissions,
create_template,
read_template,
update_template,
list_templates,
delete_template,
@ -2552,6 +2607,7 @@ impl BackendCore {
retry_background_task,
background_task_store: Arc::clone(&background_tasks_port),
ticket_tool_binder,
template_tool_binder,
}
}
@ -2640,6 +2696,7 @@ impl BackendCore {
.with_events(events)
.with_ready_sink(ready_sink)
.with_ticket_tools(Arc::clone(&self.ticket_tool_provider))
.with_template_tools(Arc::clone(&self.template_tool_provider))
.with_tool_policies(Arc::clone(&self.tool_policy_registry))
.with_mcp_tool_permissions(Arc::clone(&self.mcp_tool_permission_store)),
endpoint,
@ -4569,6 +4626,12 @@ mod mcp_serve_peer_tests {
"idea_ticket_link",
"idea_ticket_unlink",
"idea_sprint_list",
// Public template tools.
"idea_template_list",
"idea_template_read",
"idea_template_create",
"idea_template_update",
"idea_template_delete",
] {
assert!(
names.contains(&expected),
@ -4578,8 +4641,8 @@ mod mcp_serve_peer_tests {
assert!(!names.contains(&"idea_reply"));
assert_eq!(
tools.len(),
25,
"exactly the twenty-five exposed idea_* tools; got {names:?}"
30,
"exactly the thirty exposed idea_* tools; got {names:?}"
);
drop(client); // EOF ⇒ serve loop ends

163
crates/backend/src/openai_tools.rs
View File

@ -14,7 +14,7 @@ use domain::ports::{
ToolSpec,
};
use domain::{AgentId, AgentToolPolicy, IssueRef, McpToolPolicy, Project};
use infrastructure::TicketToolProvider;
use infrastructure::{TemplateToolProvider, TicketToolProvider};
use serde_json::Value;
const PROJECT_ROOT_ARG: &str = "__ideaProjectRoot";
@ -27,6 +27,7 @@ pub struct AppOpenAiToolInvoker {
policies: Arc<dyn AgentToolPolicyStore>,
mcp_tool_permissions: Arc<dyn McpToolPermissionStore>,
ticket_tools: Arc<dyn TicketToolProvider>,
template_tools: Arc<dyn TemplateToolProvider>,
}
/// Proxy injecté avant que l'orchestrateur soit construit, puis lié dans la
@ -83,6 +84,7 @@ impl AppOpenAiToolInvoker {
policies: Arc<dyn AgentToolPolicyStore>,
mcp_tool_permissions: Arc<dyn McpToolPermissionStore>,
ticket_tools: Arc<dyn TicketToolProvider>,
template_tools: Arc<dyn TemplateToolProvider>,
) -> Self {
Self {
orchestrator,
@ -90,6 +92,7 @@ impl AppOpenAiToolInvoker {
policies,
mcp_tool_permissions,
ticket_tools,
template_tools,
}
}
}
@ -170,6 +173,19 @@ impl ToolInvoker for AppOpenAiToolInvoker {
return serde_json::to_string(&value)
.map_err(|e| ToolInvocationError::Execution(format!("JSON ticket tool: {e}")));
}
if infrastructure::orchestrator::mcp::tools::is_template_tool(name) {
let value = self
.template_tools
.handle_template_tool(&project, &requester, name, value)
.await
.map_err(|e| {
let detail =
serde_json::to_string(&e.to_value()).unwrap_or_else(|_| e.to_string());
ToolInvocationError::Execution(detail)
})?;
return serde_json::to_string(&value)
.map_err(|e| ToolInvocationError::Execution(format!("JSON template tool: {e}")));
}
let command = infrastructure::orchestrator::mcp::map_tool_call(name, &value, &requester)
.map_err(|e| match e {
infrastructure::orchestrator::mcp::ToolMapError::UnknownTool(tool) => {
@ -324,7 +340,7 @@ mod tests {
AgentId, AgentMcpToolPolicyOverride, McpToolPolicy, Project, ProjectId,
ProjectMcpToolPermissions, ProjectPath, RemoteRef, StoreError, Workspace,
};
use infrastructure::TicketToolError;
use infrastructure::{TemplateToolError, TicketToolError};
use serde_json::json;
use uuid::Uuid;
@ -448,6 +464,33 @@ mod tests {
}
}
#[derive(Default)]
struct FakeTemplateTools {
calls: Mutex<Vec<(String, String, Value)>>,
}
#[async_trait]
impl TemplateToolProvider for FakeTemplateTools {
async fn handle_template_tool(
&self,
_project: &Project,
requester: &str,
name: &str,
arguments: Value,
) -> Result<Value, TemplateToolError> {
self.calls.lock().unwrap().push((
requester.to_owned(),
name.to_owned(),
arguments.clone(),
));
Ok(json!({
"ok": true,
"requester": requester,
"templateId": arguments.get("templateId").and_then(Value::as_str).unwrap_or_default(),
}))
}
}
fn issue_ref(raw: &str) -> IssueRef {
IssueRef::from_str(raw).unwrap()
}
@ -572,12 +615,14 @@ mod tests {
),
);
let ticket_tools = Arc::new(FakeTicketTools::default());
let template_tools = Arc::new(FakeTemplateTools::default());
let invoker = AppOpenAiToolInvoker::new(
Arc::clone(&core.orchestrator_service),
Arc::new(FakeProjects::with(project())) as Arc<dyn ProjectStore>,
policies,
mcp_permissions(ProjectMcpToolPermissions::default()),
ticket_tools.clone(),
template_tools,
);
let denied = invoker
@ -635,25 +680,29 @@ mod tests {
let core = crate::BackendCore::build(temp.clone());
let requester = AgentId::from_uuid(Uuid::from_u128(82)).to_string();
let ticket_tools = Arc::new(FakeTicketTools::default());
let template_tools = Arc::new(FakeTemplateTools::default());
let invoker = AppOpenAiToolInvoker::new(
Arc::clone(&core.orchestrator_service),
Arc::new(FakeProjects::with(project())) as Arc<dyn ProjectStore>,
Arc::new(FakePolicies::default()),
mcp_permissions(ProjectMcpToolPermissions::default()),
ticket_tools.clone(),
template_tools.clone(),
);
invoker
.call(
"idea_ticket_list",
&json!({
PROJECT_ROOT_ARG: "/tmp/project",
REQUESTER_ARG: requester,
})
.to_string(),
)
.await
.expect("read tool must pass the durable read-only policy");
for tool in ["idea_ticket_list", "idea_template_list"] {
invoker
.call(
tool,
&json!({
PROJECT_ROOT_ARG: "/tmp/project",
REQUESTER_ARG: requester,
})
.to_string(),
)
.await
.expect("read tool must pass the durable read-only policy");
}
for (tool, arguments) in [
(
@ -672,6 +721,18 @@ mod tests {
"idea_run_in_background",
json!({ "label": "task", "command": "echo" }),
),
(
"idea_template_create",
json!({ "name": "Base", "content": "body", "defaultProfileId": Uuid::new_v4() }),
),
(
"idea_template_update",
json!({ "templateId": Uuid::new_v4(), "content": "body" }),
),
(
"idea_template_delete",
json!({ "templateId": Uuid::new_v4() }),
),
] {
let mut payload = arguments.as_object().unwrap().clone();
payload.insert(PROJECT_ROOT_ARG.to_owned(), json!("/tmp/project"));
@ -689,6 +750,13 @@ mod tests {
let calls = ticket_tools.calls.lock().unwrap();
assert_eq!(calls.len(), 1, "only the read ticket tool should run");
assert_eq!(calls[0].1, "idea_ticket_list");
let template_calls = template_tools.calls.lock().unwrap();
assert_eq!(
template_calls.len(),
1,
"only the read template tool should run"
);
assert_eq!(template_calls[0].1, "idea_template_list");
let _ = std::fs::remove_dir_all(temp);
}
@ -701,12 +769,14 @@ mod tests {
let agent = AgentId::from_uuid(Uuid::from_u128(83));
let requester = agent.to_string();
let ticket_tools = Arc::new(FakeTicketTools::default());
let template_tools = Arc::new(FakeTemplateTools::default());
let invoker = AppOpenAiToolInvoker::new(
Arc::clone(&core.orchestrator_service),
Arc::new(FakeProjects::with(project())) as Arc<dyn ProjectStore>,
Arc::new(FakePolicies::default()),
mcp_permissions(allow_doc(agent, &["idea_ticket_update_carnet"])),
ticket_tools.clone(),
template_tools,
);
let result = invoker
@ -733,4 +803,71 @@ mod tests {
let _ = std::fs::remove_dir_all(temp);
}
#[tokio::test]
async fn openai_durable_agent_override_allows_only_explicit_template_write_tool() {
let temp = std::env::temp_dir().join(format!(
"idea-openai-template-permissions-{}",
Uuid::new_v4()
));
let core = crate::BackendCore::build(temp.clone());
let agent = AgentId::from_uuid(Uuid::from_u128(84));
let requester = agent.to_string();
let ticket_tools = Arc::new(FakeTicketTools::default());
let template_tools = Arc::new(FakeTemplateTools::default());
let template_id = Uuid::from_u128(7).to_string();
let invoker = AppOpenAiToolInvoker::new(
Arc::clone(&core.orchestrator_service),
Arc::new(FakeProjects::with(project())) as Arc<dyn ProjectStore>,
Arc::new(FakePolicies::default()),
mcp_permissions(allow_doc(agent, &["idea_template_update"])),
ticket_tools,
template_tools.clone(),
);
let result = invoker
.call(
"idea_template_update",
&json!({
PROJECT_ROOT_ARG: "/tmp/project",
REQUESTER_ARG: requester,
"templateId": template_id,
"content": "body",
})
.to_string(),
)
.await
.expect("explicit durable override should reach template provider");
let result: Value = serde_json::from_str(&result).unwrap();
assert_eq!(result["requester"], requester);
assert_eq!(result["templateId"], template_id);
for tool in ["idea_template_create", "idea_template_delete"] {
let err = invoker
.call(
tool,
&json!({
PROJECT_ROOT_ARG: "/tmp/project",
REQUESTER_ARG: requester,
"templateId": template_id,
"name": "Base",
"content": "body",
"defaultProfileId": Uuid::from_u128(9),
})
.to_string(),
)
.await
.expect_err("non-allowlisted template write must be rejected");
assert!(
matches!(err, ToolInvocationError::Rejected(ref message) if message.contains(tool)),
"expected readable rejection for {tool}, got {err:?}"
);
}
let calls = template_tools.calls.lock().unwrap();
assert_eq!(calls.len(), 1);
assert_eq!(calls[0].1, "idea_template_update");
let _ = std::fs::remove_dir_all(temp);
}
}