arclith-cli 0.10.0__tar.gz → 0.11.0__tar.gz

{arclith_cli-0.10.0 → arclith_cli-0.11.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: arclith-cli
-Version: 0.10.0
+Version: 0.11.0
 Summary: CLI scaffolding tool for arclith — hexagonal architecture framework
 Author-email: Killian KOPP <killiankopp@gmail.com>
 License:                                  Apache License
@@ -186,7 +186,7 @@ License:                                  Apache License
 License-File: LICENSE
 Keywords: arclith,cli,ddd,hexagonal-architecture,scaffold
 Requires-Python: >=3.13
-Requires-Dist: arclith>=0.13.0
+Requires-Dist: arclith>=0.14.0
 Requires-Dist: httpx>=0.27.0
 Requires-Dist: rich>=13.0.0
 Requires-Dist: typer>=0.15.0

{arclith_cli-0.10.0 → arclith_cli-0.11.0}/README.md

@@ -10,6 +10,25 @@ uv tool install "git+https://github.com/karned-rekipe/arclith.git#subdirectory=c
 
 ## Commandes
 
+### `init` — Initialiser un projet minimal
+
+Crée un projet Arclith vide de métier, avec le layout canonique `src/<package>/...`, une
+configuration minimale et un `main.py` prêt à recevoir les adapters.
+
+```bash
+# Mode interactif
+arclith-cli init
+
+# Mode direct
+arclith-cli init todo-list-service
+arclith-cli init todo-list-service --dir ~/projects
+```
+
+Cette commande ne crée aucune entité, aucun CRUD et aucun endpoint métier. Elle sert quand on veut
+construire le projet étape par étape avec `add-entity`, `add-usecase`, puis `add-adapter`.
+
+---
+
 ### `new` — Créer un projet
 
 Scaffold un nouveau projet arclith depuis le template officiel `_sample`.
@@ -55,7 +74,8 @@ La commande ne génère aucun CRUD, aucun port repository, aucun adapter et aucu
 
 ### `add-usecase` — Ajouter un cas d'usage
 
-Crée uniquement le fichier minimal d'un cas d'usage dans `src/<package>/application/use_cases/`.
+Crée le port inbound minimal dans `src/<package>/domain/ports/inbound/`, puis le fichier minimal du
+cas d'usage dans `src/<package>/application/use_cases/`.
 
 ```bash
 cd my-recipe-service
@@ -66,12 +86,35 @@ arclith-cli add-usecase find-by-name
 Fichier généré :
 
 ```text
+src/<package>/domain/ports/inbound/plan_shopping_list.py
 src/<package>/application/use_cases/plan_shopping_list.py
 ```
 
 Le nom peut être fourni en PascalCase, snake_case ou kebab-case. Le suffixe `UseCase` est normalisé : `PlanShoppingListUseCase` et `plan-shopping-list-use-case` génèrent tous les deux `PlanShoppingListUseCase`.
 
-Comme `add-entity`, cette commande ne câble pas FastAPI, FastMCP, LangGraph, un repository ou un service. Les adapters se branchent ensuite explicitement avec `add-adapter`.
+Comme `add-entity`, cette commande ne câble pas FastAPI, FastMCP, LangGraph, un repository ou un service. Les adapters se branchent ensuite explicitement avec `add-adapter` et devraient dépendre du port inbound généré.
+
+---
+
+### `add-planner` — Ajouter un planner applicatif
+
+Crée uniquement le fichier minimal d'un planner dans `src/<package>/application/planners/`.
+
+```bash
+cd my-recipe-service
+arclith-cli add-planner IngredientIntent
+arclith-cli add-planner command-router
+```
+
+Fichier généré :
+
+```text
+src/<package>/application/planners/ingredient_intent.py
+```
+
+Le planner est le composant applicatif qui transforme une demande naturelle en commande ou DTO
+structuré. Il ne remplace pas LangGraph : LangGraph orchestre les nœuds, tandis que le planner porte
+la traduction d'intention. Le fichier généré reste volontairement vide de logique métier.
 
 ---
 
@@ -92,6 +135,7 @@ arclith-cli add-adapter --adapter duckdb --all-entities --path data/ --no-activa
 arclith-cli add-adapter --adapter mariadb --entity Recipe --param database=my_recipe_service --param user=app --yes
 arclith-cli add-adapter --capability api --adapter fastapi --param port=8080 --yes
 arclith-cli add-adapter --capability mcp --adapter fastmcp --param port=8081 --yes
+arclith-cli add-adapter --capability llm --adapter lmstudio --param model_name=qwen/qwen3.5-9b --yes
 arclith-cli add-adapter --capability agent --adapter langgraph --param graph_name=recipe_agent --yes
 arclith-cli add-adapter --capability observability --adapter langsmith
 arclith-cli add-adapter --capability observability --adapter opentelemetry --param service_name=my_recipe_service --yes
@@ -100,25 +144,28 @@ arclith-cli add-adapter --capability repository --adapter memory --entity Recipe
 
 **Étapes du wizard :**
 
-1. **Type d'adapter** — selon la capacité : `memory` · `mongodb` · `duckdb` · `mariadb` · `fastapi` · `fastmcp` · `langgraph` · `langsmith` · `opentelemetry`
-2. **Entité(s) cible(s)** — détectées automatiquement pour les adapters entity-scoped ; ignorées pour les transports globaux, `agent/langgraph` et les adapters d'observability
+1. **Type d'adapter** — selon la capacité : `memory` · `mongodb` · `duckdb` · `mariadb` · `fastapi` · `fastmcp` · `lmstudio` · `openai` · `anthropic` · `langgraph` · `langsmith` · `opentelemetry`
+2. **Entité(s) cible(s)** — détectées automatiquement pour les adapters entity-scoped ; ignorées pour les transports globaux, `llm/*`, `agent/langgraph` et les adapters d'observability
 3. **Paramètres** — questions spécifiques à l'adapter :
    - `mongodb` → `db_name`, `multitenant`
    - `duckdb` → `path`
    - `mariadb` → `host`, `port`, `database`, `user`, `driver`, `table_prefix`
    - `fastapi` → `host`, `port`, `reload`
    - `fastmcp` → `host`, `port`
+   - `lmstudio` → `model_name`, `base_url`, `api_key`
+   - `openai` → `model_name`, `base_url`, `OPENAI_API_KEY`
+   - `anthropic` → `model_name`, `ANTHROPIC_API_KEY`
    - `langgraph` → `graph_name`
    - `langsmith` → `tracing`, `project`, `endpoint`, `LANGSMITH_API_KEY`
    - `opentelemetry` → `service_name`, `endpoint`, `protocol`, `traces`, `metrics`, `instrument_fastapi`
    - `memory` → aucun paramètre
-4. **Activation** — met à jour `config/adapters/adapters.yaml` pour les capacités à sélecteur (`repository: <adapter>` ou `observability: <adapter>`) ; `api/fastapi`, `mcp/fastmcp` et `agent/langgraph` sont exposés par leurs fichiers `config/adapters/inbound/*.yaml`
+4. **Activation** — met à jour `config/adapters/adapters.yaml` pour les capacités activables (`repository: <adapter>` ou `observability.enabled: [<adapter>, ...]`) ; `api/fastapi`, `mcp/fastmcp`, `llm/*` et `agent/langgraph` sont exposés par leurs fichiers de configuration scopés
 5. **Récapitulatif** — liste des fichiers créés ou remplacés avant confirmation
 
 | Option | Défaut | Description |
 |--------|--------|-------------|
-| `--capability` | `repository` | Capacité cible du catalogue standardisé (`repository`, `api`, `mcp`, `agent`, `observability`) |
-| `--adapter` / `-a` | interactif | Adapter du catalogue : `memory`, `mongodb`, `duckdb`, `mariadb`, `fastapi`, `fastmcp`, `langgraph`, `langsmith`, `opentelemetry` |
+| `--capability` | `repository` | Capacité cible du catalogue standardisé (`repository`, `api`, `mcp`, `llm`, `agent`, `observability`) |
+| `--adapter` / `-a` | interactif | Adapter du catalogue : `memory`, `mongodb`, `duckdb`, `mariadb`, `fastapi`, `fastmcp`, `lmstudio`, `openai`, `anthropic`, `langgraph`, `langsmith`, `opentelemetry` |
 | `--entity` / `-e` | auto si une seule entité | Entité cible, liste séparée par virgule acceptée |
 | `--all-entities` | `false` | Génère l'adapter pour toutes les entités détectées |
 | `--activate/--no-activate` | `--activate` | Met à jour `config/adapters/adapters.yaml` quand la capacité expose une clé d'activation |
@@ -144,16 +191,21 @@ src/<package>/infrastructure/containers/<entity>_container.py  # RepositoryRegis
 
 ```bash
 uv add "arclith[langgraph]"
+arclith-cli add-adapter --capability llm --adapter lmstudio --param model_name=qwen/qwen3.5-9b --yes
 arclith-cli add-adapter --capability agent --adapter langgraph
 arclith-cli add-adapter --capability observability --adapter langsmith
 uv run langgraph dev --no-browser --allow-blocking --port 2024
 ```
 
+L'adapter `llm/lmstudio` génère `config/adapters/outbound/lm.yaml`, chargé dans
+`AppConfig.adapters.lm`. Les adapters `llm/openai` et `llm/anthropic` génèrent aussi un mapping
+`config/secrets.yaml` vers `OPENAI_API_KEY` ou `ANTHROPIC_API_KEY`.
+
 L'adapter `agent/langgraph` génère `langgraph.json`, `config/adapters/inbound/langgraph.yaml` et
 `src/<package>/adapters/inbound/langgraph/agent.py`. Le projet ne modifie ensuite que ce fichier pour
 son agent. Comme `fastapi` et `fastmcp`, LangGraph est configuré par son nom produit dans
 `AppConfig.langgraph`, sans `adapters.agent`. L'adapter `observability/langsmith` génère
-`config/adapters/outbound/langsmith.yaml`, met
+`config/adapters/outbound/langsmith.yaml`, l'ajoute à `observability.enabled`, met
 à jour `.env` et ajoute `.env` au `.gitignore` si besoin. LangSmith Studio devient l'endroit standard
 pour tester les agents. Une `LANGSMITH_API_KEY` déjà présente est conservée si aucune nouvelle valeur
 n'est fournie.
@@ -166,8 +218,10 @@ arclith-cli add-adapter --capability observability --adapter opentelemetry --par
 ```
 
 L'adapter `observability/opentelemetry` génère `config/adapters/outbound/opentelemetry.yaml`, met à
-jour `.env`, active `observability: opentelemetry` et branche l'instrumentation FastAPI quand
-`Arclith.fastapi()` construit l'application.
+jour `.env`, l'ajoute à `observability.enabled` et branche l'instrumentation FastAPI quand
+`Arclith.fastapi()` construit l'application. Il peut être activé en même temps que LangSmith.
+Le fichier `opentelemetry.yaml` ne porte pas de flag `enabled`: l'activation se fait uniquement dans
+`observability.enabled`.
 
 Parcours complet avec entité, API, LangGraph, LangSmith et LM Studio:
 [`docs/agent-quickstart.md`](../docs/agent-quickstart.md).
@@ -236,11 +290,12 @@ config/
   soft_delete.yaml                # soft_delete: { retention_days }
   secrets.yaml                    # secrets: { resolver, mappings, vault, yaml }
   adapters/
-    adapters.yaml                 # adapters: { logger, repository }   ← adapter actif
+    adapters.yaml                 # adapters: { logger, repository, observability.enabled }
     outbound/
       mongodb.yaml                # adapters.mongodb: { db_name, multitenant }
       duckdb.yaml                 # adapters.duckdb: { path, multitenant }
       mariadb.yaml                # adapters.mariadb: { host, port, database, user, ... }
+      lm.yaml                     # adapters.lm: { provider, model_name, api_key, base_url }
       langsmith.yaml              # adapters.langsmith: { tracing, project, endpoint, ... }
       opentelemetry.yaml          # adapters.opentelemetry: { endpoint, protocol, traces, metrics, ... }
     inbound/
@@ -258,7 +313,10 @@ Pour changer l'adapter actif sans passer par le wizard :
 ```yaml
 # config/adapters/adapters.yaml
 repository: duckdb   # memory | mongodb | duckdb | mariadb
-observability: langsmith   # none | langsmith | opentelemetry
+observability:
+  enabled:
+    - langsmith
+    - opentelemetry
 ```
 
 Pour MariaDB, ne committez pas le mot de passe. Mappez `adapters.mariadb.password` ou `adapters.mariadb.url` via `config/secrets.yaml`, un resolver `env` ou Vault.

arclith_cli-0.11.0/arclith_cli/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.11.0"

{arclith_cli-0.10.0 → arclith_cli-0.11.0}/arclith_cli/add_adapter.py

@@ -5,6 +5,7 @@ from pathlib import Path
 from typing import Any
 
 import typer
+import yaml
 from rich.console import Console
 from rich.panel import Panel
 from rich.prompt import Confirm, Prompt
@@ -20,6 +21,7 @@ from .capabilities import (
     AdapterSpec,
     CapabilitySpec,
     ParameterSpec,
+    SecretMappingSpec,
     capability_names,
     get_capability,
 )
@@ -384,7 +386,7 @@ def _show_recap(
         cfg_path = project_dir / "config" / "adapters" / "adapters.yaml"
         table.add_row(
             str(cfg_path.relative_to(project_dir)),
-            f"[cyan]mis à jour ({capability.activation_config_key})[/cyan]",
+            f"[cyan]mis à jour ({_activation_config_label(capability)})[/cyan]",
         )
 
     console.print()
@@ -409,6 +411,10 @@ def _list_generated_files(
         gitignore = project_dir / ".gitignore"
         files.append((gitignore, "mis à jour" if gitignore.exists() else "créé"))
 
+    if adapter.has_secret_mappings():
+        secrets_file = project_dir / "config" / "secrets.yaml"
+        files.append((secrets_file, "mis à jour" if secrets_file.exists() else "créé"))
+
     template_vars = _file_template_vars(project_dir, paths, adapter, params={})
     for file_template in adapter.file_templates:
         path = project_dir / render(file_template.path, template_vars)
@@ -430,6 +436,12 @@ def _list_generated_files(
     return files
 
 
+def _activation_config_label(capability: CapabilitySpec) -> str:
+    if capability.name == "observability":
+        return "observability.enabled"
+    return capability.activation_config_key or ""
+
+
 # ── Step 5 : generate ─────────────────────────────────────────────────────────
 
 def _generate(
@@ -459,6 +471,11 @@ def _generate(
         _ensure_env_is_ignored(project_dir)
         console.print(f"[green]✓[/green] {env_path.relative_to(project_dir)}")
 
+    if adapter.has_secret_mappings():
+        secrets_path = project_dir / "config" / "secrets.yaml"
+        _merge_secrets_file(secrets_path, adapter.secret_mappings)
+        console.print(f"[green]✓[/green] {secrets_path.relative_to(project_dir)}")
+
     for file_template in adapter.file_templates:
         generated_path = project_dir / render(file_template.path, params)
         generated_path.parent.mkdir(parents=True, exist_ok=True)
@@ -538,6 +555,10 @@ def _file_template_vars(
 def _update_active_capability(project_dir: Path, capability: CapabilitySpec, adapter: AdapterSpec) -> None:
     if capability.activation_config_key is None:
         return
+    if capability.name == "observability":
+        _enable_observability_adapter(project_dir, adapter)
+        return
+
     cfg = project_dir / "config" / "adapters" / "adapters.yaml"
     key = capability.activation_config_key
     escaped_key = re.escape(key)
@@ -554,6 +575,29 @@ def _update_active_capability(project_dir: Path, capability: CapabilitySpec, ada
     console.print(f"[cyan]↺[/cyan] config/adapters/adapters.yaml → {key}: {adapter.name}")
 
 
+def _enable_observability_adapter(project_dir: Path, adapter: AdapterSpec) -> None:
+    cfg = project_dir / "config" / "adapters" / "adapters.yaml"
+    data = _read_yaml_mapping(cfg)
+    existing = data.get("observability")
+    if isinstance(existing, dict) and isinstance(existing.get("enabled"), list):
+        enabled = []
+        for name in existing["enabled"]:
+            if isinstance(name, str) and name not in enabled:
+                enabled.append(name)
+    else:
+        enabled = []
+
+    if adapter.name not in enabled:
+        enabled.append(adapter.name)
+
+    data["observability"] = {"enabled": enabled}
+    cfg.parent.mkdir(parents=True, exist_ok=True)
+    cfg.write_text(yaml.safe_dump(data, sort_keys=False, allow_unicode=True), encoding="utf-8")
+    console.print(
+        f"[cyan]↺[/cyan] config/adapters/adapters.yaml → observability.enabled += {adapter.name}"
+    )
+
+
 def _parse_env_template(rendered: str) -> dict[str, str]:
     values: dict[str, str] = {}
     for line in rendered.splitlines():
@@ -595,6 +639,36 @@ def _merge_env_file(env_path: Path, updates: dict[str, str]) -> None:
     env_path.write_text("\n".join(merged_lines).rstrip("\n") + "\n", encoding="utf-8")
 
 
+def _merge_secrets_file(secrets_path: Path, mappings: tuple[SecretMappingSpec, ...]) -> None:
+    secrets_path.parent.mkdir(parents=True, exist_ok=True)
+    data = _read_yaml_mapping(secrets_path)
+    resolver = data.get("resolver")
+    if not isinstance(resolver, str) or not resolver.strip():
+        data["resolver"] = "env"
+
+    existing_mappings = data.get("mappings")
+    if not isinstance(existing_mappings, dict):
+        existing_mappings = {}
+
+    merged_mappings = dict(existing_mappings)
+    for mapping in mappings:
+        merged_mappings[mapping.field_path] = mapping.secret_key
+    data["mappings"] = merged_mappings
+
+    rendered = yaml.safe_dump(data, sort_keys=False, allow_unicode=True)
+    secrets_path.write_text(rendered, encoding="utf-8")
+
+
+def _read_yaml_mapping(path: Path) -> dict[str, Any]:
+    if not path.exists():
+        return {}
+
+    loaded = yaml.safe_load(path.read_text(encoding="utf-8")) or {}
+    if isinstance(loaded, dict):
+        return dict(loaded)
+    return {}
+
+
 def _ensure_env_is_ignored(project_dir: Path) -> None:
     gitignore = project_dir / ".gitignore"
     if gitignore.exists():

{arclith_cli-0.10.0 → arclith_cli-0.11.0}/arclith_cli/capabilities.py

@@ -38,6 +38,18 @@ class FileTemplateSpec:
         }
 
 
+@dataclass(frozen=True)
+class SecretMappingSpec:
+    field_path: str
+    secret_key: str
+
+    def to_dict(self) -> dict[str, str]:
+        return {
+            "field_path": self.field_path,
+            "secret_key": self.secret_key,
+        }
+
+
 @dataclass(frozen=True)
 class AdapterSpec:
     name: str
@@ -49,6 +61,7 @@ class AdapterSpec:
     env_path: str | None = None
     env_template: str = ""
     file_templates: tuple[FileTemplateSpec, ...] = ()
+    secret_mappings: tuple[SecretMappingSpec, ...] = ()
     parameters: tuple[ParameterSpec, ...] = ()
     entity_scoped: bool = True
 
@@ -61,6 +74,9 @@ class AdapterSpec:
     def has_file_templates(self) -> bool:
         return bool(self.file_templates)
 
+    def has_secret_mappings(self) -> bool:
+        return bool(self.secret_mappings)
+
     def to_dict(self) -> dict[str, Any]:
         return {
             "name": self.name,
@@ -70,6 +86,7 @@ class AdapterSpec:
             "config_path": self.config_path,
             "env_path": self.env_path,
             "file_templates": [file_template.to_dict() for file_template in self.file_templates],
+            "secret_mappings": [secret_mapping.to_dict() for secret_mapping in self.secret_mappings],
             "parameters": [parameter.to_dict() for parameter in self.parameters],
             "entity_scoped": self.entity_scoped,
         }
@@ -106,14 +123,14 @@ class CapabilitySpec:
 REPOSITORY_CAPABILITY = CapabilitySpec(
     name="repository",
     layer="outbound",
-    description="Persistance des entites metier derriere un port repository.",
+    description="Persistance des entités métier derrière un port repository.",
     activation_config_key="repository",
     adapters=(
         AdapterSpec(
             name="memory",
             capability="repository",
             layer="outbound",
-            description="Stockage volatile en memoire pour dev, tests et smoke locaux.",
+            description="Stockage volatile en mémoire pour dev, tests et smoke locaux.",
         ),
         AdapterSpec(
             name="mongodb",
@@ -144,7 +161,7 @@ db_name: {db_name}   # uri -> secrets.yaml ou Vault (fallback single-tenant)
             name="duckdb",
             capability="repository",
             layer="outbound",
-            description="Repository fichier local pour SQL analytique et demos sans serveur.",
+            description="Repository fichier local pour SQL analytique et démos sans serveur.",
             config_path="config/adapters/outbound/duckdb.yaml",
             config_template="""\
 multitenant: false
@@ -227,7 +244,7 @@ API_CAPABILITY = CapabilitySpec(
             name="fastapi",
             capability="api",
             layer="inbound",
-            description="Application FastAPI configuree par Arclith.fastapi().",
+            description="Application FastAPI configurée par Arclith.fastapi().",
             config_path="config/adapters/inbound/fastapi.yaml",
             config_template="""\
 host: {host}
@@ -269,7 +286,7 @@ MCP_CAPABILITY = CapabilitySpec(
             name="fastmcp",
             capability="mcp",
             layer="inbound",
-            description="Serveur FastMCP configure par Arclith.fastmcp() et les runners MCP.",
+            description="Serveur FastMCP configuré par Arclith.fastmcp() et les runners MCP.",
             config_path="config/adapters/inbound/fastmcp.yaml",
             config_template="""\
 host: {host}
@@ -294,17 +311,144 @@ port: {port}
     ),
 )
 
+LLM_CAPABILITY = CapabilitySpec(
+    name="llm",
+    layer="outbound",
+    description="Configuration LLM pour planners et agents via une factory Arclith.",
+    activation_config_key=None,
+    adapters=(
+        AdapterSpec(
+            name="lmstudio",
+            capability="llm",
+            layer="outbound",
+            description="LLM local LM Studio exposé par l'API OpenAI-compatible.",
+            config_path="config/adapters/outbound/lm.yaml",
+            config_template="""\
+provider: openai
+model_name: "{model_name}"
+api_key: "{api_key}"
+base_url: "{base_url}"
+""",
+            parameters=(
+                ParameterSpec(
+                    name="model_name",
+                    kind="string",
+                    prompt="Model ID LM Studio",
+                    default="remplacer-par-le-model-id-lm-studio",
+                ),
+                ParameterSpec(
+                    name="base_url",
+                    kind="string",
+                    prompt="Endpoint OpenAI-compatible LM Studio",
+                    default="http://127.0.0.1:1234/v1",
+                ),
+                ParameterSpec(
+                    name="api_key",
+                    kind="string",
+                    prompt="API key LM Studio",
+                    default="lm-studio",
+                    secret=True,
+                ),
+            ),
+            entity_scoped=False,
+        ),
+        AdapterSpec(
+            name="openai",
+            capability="llm",
+            layer="outbound",
+            description="Modèle OpenAI via protocole OpenAI-compatible.",
+            config_path="config/adapters/outbound/lm.yaml",
+            config_template="""\
+provider: openai
+model_name: "{model_name}"
+api_key: ""
+base_url: "{base_url}"
+""",
+            env_path=".env",
+            env_template="""\
+OPENAI_API_KEY={api_key}
+""",
+            secret_mappings=(
+                SecretMappingSpec(
+                    field_path="adapters.lm.api_key",
+                    secret_key="OPENAI_API_KEY",
+                ),
+            ),
+            parameters=(
+                ParameterSpec(
+                    name="model_name",
+                    kind="string",
+                    prompt="Modèle OpenAI",
+                    default="gpt-4o-mini",
+                ),
+                ParameterSpec(
+                    name="base_url",
+                    kind="string",
+                    prompt="Endpoint OpenAI-compatible",
+                    default="https://api.openai.com/v1",
+                ),
+                ParameterSpec(
+                    name="api_key",
+                    kind="string",
+                    prompt="OPENAI_API_KEY",
+                    default="",
+                    secret=True,
+                ),
+            ),
+            entity_scoped=False,
+        ),
+        AdapterSpec(
+            name="anthropic",
+            capability="llm",
+            layer="outbound",
+            description="Modèle Anthropic pour planners et agents.",
+            config_path="config/adapters/outbound/lm.yaml",
+            config_template="""\
+provider: anthropic
+model_name: "{model_name}"
+api_key: ""
+""",
+            env_path=".env",
+            env_template="""\
+ANTHROPIC_API_KEY={api_key}
+""",
+            secret_mappings=(
+                SecretMappingSpec(
+                    field_path="adapters.lm.api_key",
+                    secret_key="ANTHROPIC_API_KEY",
+                ),
+            ),
+            parameters=(
+                ParameterSpec(
+                    name="model_name",
+                    kind="string",
+                    prompt="Modèle Anthropic",
+                    default="claude-sonnet-4-5",
+                ),
+                ParameterSpec(
+                    name="api_key",
+                    kind="string",
+                    prompt="ANTHROPIC_API_KEY",
+                    default="",
+                    secret=True,
+                ),
+            ),
+            entity_scoped=False,
+        ),
+    ),
+)
+
 AGENT_CAPABILITY = CapabilitySpec(
     name="agent",
     layer="inbound",
-    description="Adapter agent qui expose les cas d'usage metier via un runtime IA.",
+    description="Adapter agent qui expose les cas d'usage métier via un runtime IA.",
     activation_config_key=None,
     adapters=(
         AdapterSpec(
             name="langgraph",
             capability="agent",
             layer="inbound",
-            description="Entrypoint LangGraph Studio base sur la tuyauterie Arclith.",
+            description="Entrypoint LangGraph Studio basé sur la tuyauterie Arclith.",
             config_path="config/adapters/inbound/langgraph.yaml",
             config_template="""\
 name: "{graph_name}"
@@ -375,7 +519,7 @@ agent = arclith.langgraph(AgentState, register_agent, name="{graph_name}")
 OBSERVABILITY_CAPABILITY = CapabilitySpec(
     name="observability",
     layer="outbound",
-    description="Observabilite et boucle de test agent via LangSmith Studio.",
+    description="Observabilité activable en parallèle via LangSmith et OpenTelemetry.",
     activation_config_key="observability",
     adapters=(
         AdapterSpec(
@@ -435,7 +579,6 @@ LANGSMITH_API_KEY={api_key}
             description="Export OTLP traces/metrics et instrumentation FastAPI.",
             config_path="config/adapters/outbound/opentelemetry.yaml",
             config_template="""\
-enabled: {enabled}
 service_name: "{service_name}"
 endpoint: "{endpoint}"
 protocol: "{protocol}"
@@ -453,12 +596,6 @@ OTEL_EXPORTER_OTLP_PROTOCOL={protocol}
 OTEL_EXPORTER_OTLP_HEADERS={headers}
 """,
             parameters=(
-                ParameterSpec(
-                    name="enabled",
-                    kind="boolean",
-                    prompt="Activer OpenTelemetry",
-                    default=True,
-                ),
                 ParameterSpec(
                     name="service_name",
                     kind="string",
@@ -486,7 +623,7 @@ OTEL_EXPORTER_OTLP_HEADERS={headers}
                 ParameterSpec(
                     name="metrics",
                     kind="boolean",
-                    prompt="Exporter les metriques",
+                    prompt="Exporter les métriques",
                     default=False,
                 ),
                 ParameterSpec(
@@ -498,7 +635,7 @@ OTEL_EXPORTER_OTLP_HEADERS={headers}
                 ParameterSpec(
                     name="metrics_export_interval_millis",
                     kind="string",
-                    prompt="Intervalle export metriques en ms",
+                    prompt="Intervalle export métriques en ms",
                     default="60000",
                 ),
                 ParameterSpec(
@@ -518,6 +655,7 @@ CAPABILITY_CATALOG = (
     REPOSITORY_CAPABILITY,
     API_CAPABILITY,
     MCP_CAPABILITY,
+    LLM_CAPABILITY,
     AGENT_CAPABILITY,
     OBSERVABILITY_CAPABILITY,
 )