livequill 0.2.0__py3-none-any.whl

livequill/__init__.py

@@ -0,0 +1,3 @@
+"""livequill : barre de prompt flottante qui fait éditer un site local par n'importe quel modèle."""
+__version__ = '0.2.0'
+APP = 'livequill'

livequill/__main__.py

@@ -0,0 +1,5 @@
+import sys
+
+from .cli import main
+
+sys.exit(main())

livequill/adapters/__init__.py

@@ -0,0 +1,65 @@
+"""Registre des fournisseurs. Ajouter un fournisseur = écrire un adaptateur et l'inscrire dans KINDS."""
+from .anthropic import AnthropicAdapter
+from .base import Adapter, ToolsUnsupported
+from .cli import CLIAdapter
+from .gemini import GeminiAdapter
+from .ollama import OllamaAdapter
+from .openai import CustomAdapter, LlamaCppAdapter, LMStudioAdapter, MistralAdapter, OpenAIAdapter, OpenRouterAdapter
+
+# group : « cloud », « local » ou « cli » (rangement de la page de setup)
+# fields : champs du formulaire — key (clé API), base_url, model (nom libre), extra_models, num_ctx
+KINDS = {
+    # --- API cloud : url = page où créer la clé --------------------------------------------------------
+    'anthropic': {'label': 'Anthropic', 'group': 'cloud', 'adapter': AnthropicAdapter, 'fields': ['key'], 'env': 'ANTHROPIC_API_KEY',
+                  'url': 'https://console.anthropic.com/settings/keys', 'url_label': 'Créer une clé',
+                  'help': 'Clé sur console.anthropic.com → Settings → API keys'},
+    'openai': {'label': 'OpenAI', 'group': 'cloud', 'adapter': OpenAIAdapter, 'fields': ['key'], 'env': 'OPENAI_API_KEY',
+               'url': 'https://platform.openai.com/api-keys', 'url_label': 'Créer une clé',
+               'help': 'Clé sur platform.openai.com → API keys'},
+    'gemini': {'label': 'Google Gemini', 'group': 'cloud', 'adapter': GeminiAdapter, 'fields': ['key'], 'env': 'GEMINI_API_KEY',
+               'url': 'https://aistudio.google.com/apikey', 'url_label': 'Créer une clé',
+               'help': 'Clé sur aistudio.google.com → Get API key'},
+    'mistral': {'label': 'Mistral', 'group': 'cloud', 'adapter': MistralAdapter, 'fields': ['key'], 'env': 'MISTRAL_API_KEY',
+                'url': 'https://console.mistral.ai/api-keys', 'url_label': 'Créer une clé',
+                'help': 'Clé sur console.mistral.ai → API keys'},
+    'openrouter': {'label': 'OpenRouter', 'group': 'cloud', 'adapter': OpenRouterAdapter, 'fields': ['key'], 'env': 'OPENROUTER_API_KEY',
+                   'url': 'https://openrouter.ai/keys', 'url_label': 'Créer une clé',
+                   'help': 'Clé sur openrouter.ai/keys — donne accès à des centaines de modèles'},
+    # --- modèles locaux : url = page de téléchargement ; « Autre » pour tout serveur compatible OpenAI ----
+    'ollama': {'label': 'Ollama', 'group': 'local', 'adapter': OllamaAdapter, 'fields': ['base_url', 'num_ctx'],
+               'url': 'https://ollama.com/download', 'url_label': 'Télécharger',
+               'help': 'ollama serve, puis ollama pull qwen2.5:7b-instruct (ou un autre modèle qui gère les tools)'},
+    'lmstudio': {'label': 'LM Studio', 'group': 'local', 'adapter': LMStudioAdapter, 'fields': ['base_url'],
+                 'url': 'https://lmstudio.ai', 'url_label': 'Télécharger',
+                 'help': 'Onglet Developer → Start server (port 1234 par défaut)'},
+    'llamacpp': {'label': 'llama.cpp server', 'group': 'local', 'adapter': LlamaCppAdapter, 'fields': ['base_url'],
+                 'url': 'https://github.com/ggml-org/llama.cpp', 'url_label': 'Installer',
+                 'help': 'llama-server -m modele.gguf --jinja (port 8080 par défaut, --jinja active les tools)'},
+    'custom': {'label': 'Autre', 'group': 'local', 'adapter': CustomAdapter, 'fields': ['base_url', 'key', 'model'], 'multi': True,
+               'help': 'N’importe quel serveur compatible OpenAI (/v1/chat/completions) : vLLM, LocalAI, Jan, Groq, DeepSeek, un proxy maison…'},
+    # --- agents CLI : login = commande pour se connecter au compte du fournisseur ------------------------
+    'cli-claude': {'label': 'Claude Code (CLI)', 'group': 'cli', 'adapter': CLIAdapter, 'command': 'claude', 'fields': ['extra_models'],
+                   'url': 'https://code.claude.com/docs', 'url_label': 'Installer', 'login': 'claude, puis /login',
+                   'help': 'Utilise « claude -p » dans le dossier du projet, avec ton compte Claude Code (CLI, ou celle intégrée à l’app Claude Desktop)'},
+    'cli-codex': {'label': 'Codex (CLI)', 'group': 'cli', 'adapter': CLIAdapter, 'command': 'codex', 'fields': ['extra_models'],
+                  'url': 'https://github.com/openai/codex', 'url_label': 'Installer', 'login': 'codex login',
+                  'help': 'Utilise « codex exec » dans le dossier du projet, avec ton compte (CLI, ou celle intégrée à l’app ChatGPT ou Codex). Écriture limitée au projet, mais Codex peut lire tout ton disque'},
+    'cli-gemini': {'label': 'Gemini CLI', 'group': 'cli', 'adapter': CLIAdapter, 'command': 'gemini', 'fields': ['extra_models'],
+                   'url': 'https://github.com/google-gemini/gemini-cli', 'url_label': 'Installer', 'login': 'gemini (connexion au 1er lancement)',
+                   'help': 'Utilise « gemini -p » dans le dossier du projet'},
+}
+
+
+def make(conf, transport=None):
+    kind = KINDS[conf['type']]
+    conf = dict(conf)
+    if 'command' in kind:
+        conf.setdefault('command', kind['command'])
+    return kind['adapter'](conf, transport)
+
+
+def public_kinds():
+    return {k: {x: v for x, v in d.items() if x != 'adapter'} for k, d in KINDS.items()}
+
+
+__all__ = ['Adapter', 'KINDS', 'ToolsUnsupported', 'make', 'public_kinds']

livequill/adapters/anthropic.py

@@ -0,0 +1,128 @@
+"""Anthropic Messages API (HTTP brut, en flux SSE)."""
+import json, re
+
+from ..net import sse
+from .base import Adapter, levels
+
+VERSION = '2023-06-01'
+FAST_MODELS = {'claude-opus-5-5', 'claude-opus-5', 'claude-opus-4-8'}
+# Modèles qui acceptent fallbacks: "default" (re-routage côté serveur en cas de refus)
+FALLBACK_MODELS = {'claude-fable-5-1', 'claude-opus-5-5', 'claude-opus-5', 'claude-sonnet-5-5'}
+KNOWN = [('claude-opus-5-5', 'Opus 5.5'), ('claude-sonnet-5-5', 'Sonnet 5.5'), ('claude-haiku-5-5', 'Haiku 5.5'),
+         ('claude-fable-5-1', 'Fable 5.1')]
+
+
+def effort_levels(model):
+    if re.match(r'claude-(opus|sonnet|haiku|fable|mythos)-5', model) or re.match(r'claude-opus-4-[78]', model):
+        return levels('low', 'medium', 'high', 'xhigh', 'max')
+    if re.match(r'claude-(opus|sonnet)-4-6', model):
+        return levels('low', 'medium', 'high', 'max')
+    return None
+
+
+class AnthropicAdapter(Adapter):
+    kind = 'anthropic'
+    default_base = 'https://api.anthropic.com'
+
+    def headers(self, betas=()):
+        h = {'x-api-key': self.key, 'anthropic-version': VERSION}
+        if betas:
+            h['anthropic-beta'] = ','.join(betas)
+        return h
+
+    def list_models(self):
+        data = self.http.json('GET', f'{self.base}/v1/models?limit=100', self.headers())
+        out = [{'id': m['id'], 'label': m.get('display_name') or m['id'], 'meta': {}} for m in data.get('data', [])]
+        return out or [{'id': i, 'label': l, 'meta': {}} for i, l in KNOWN]
+
+    def caps(self, model, meta=None):
+        return {'tools': True, 'vision': True, 'effort': effort_levels(model), 'fast': model in FAST_MODELS}
+
+    def convert(self, messages):
+        out = []
+        for m in messages:
+            if m['role'] == 'tool':
+                blocks = [{'type': 'tool_result', 'tool_use_id': r['id'], 'content': r['content'] or '(vide)',
+                           **({'is_error': True} if r.get('is_error') else {})} for r in m['results']]
+                out.append({'role': 'user', 'content': blocks})
+                continue
+            blocks = []
+            for p in m['content']:
+                t = p['type']
+                if t == 'text' and p['text']:
+                    blocks.append({'type': 'text', 'text': p['text']})
+                elif t == 'image':
+                    blocks.append({'type': 'image', 'source': {'type': 'base64', 'media_type': p['media_type'], 'data': p['data']}})
+                elif t == 'tool_call':
+                    blocks.append({'type': 'tool_use', 'id': p['id'], 'name': p['name'], 'input': p['args']})
+                elif t == 'raw' and p.get('provider') == self.kind:
+                    blocks.append(p['block'])   # blocs de réflexion renvoyés tels quels pendant la boucle
+            out.append({'role': m['role'], 'content': blocks or [{'type': 'text', 'text': '…'}]})
+        return out
+
+    def build_request(self, model, system, messages, tools, opts):
+        body = {'model': model, 'max_tokens': 32000, 'stream': True, 'system': system, 'messages': self.convert(messages)}
+        if tools:
+            body['tools'] = [{'name': t['name'], 'description': t['description'], 'input_schema': t['parameters']} for t in tools]
+        betas = []
+        if effort_levels(model):
+            body['thinking'] = {'type': 'adaptive', 'display': 'summarized'}
+            if opts.get('effort') in dict(effort_levels(model)):
+                body['output_config'] = {'effort': opts['effort']}
+        if opts.get('fast') and model in FAST_MODELS:
+            body['speed'] = 'fast'
+            betas.append('fast-mode-2026-02-01')
+        elif model in FALLBACK_MODELS and self.conf.get('fallbacks', True):
+            body['fallbacks'] = 'default'
+            betas.append('server-side-fallback-2026-07-01')
+        return 'POST', f'{self.base}/v1/messages', self.headers(betas), body
+
+    def parse_stream(self, lines):
+        blocks, stop = {}, 'end'
+        for _event, data in sse(lines):
+            try:
+                ev = json.loads(data)
+            except ValueError:
+                continue
+            t = ev.get('type')
+            if t == 'error':
+                raise RuntimeError(ev.get('error', {}).get('message') or data)
+            if t == 'content_block_start':
+                b = dict(ev['content_block'])
+                if b.get('type') == 'tool_use':
+                    b['_json'] = ''
+                blocks[ev['index']] = b
+            elif t == 'content_block_delta':
+                b, d = blocks.get(ev['index']), ev['delta']
+                if b is None:
+                    continue
+                dt = d.get('type')
+                if dt == 'text_delta':
+                    b['text'] = b.get('text', '') + d['text']
+                    yield {'type': 'delta', 'text': d['text']}
+                elif dt == 'thinking_delta':
+                    b['thinking'] = b.get('thinking', '') + d['thinking']
+                    yield {'type': 'thinking', 'text': d['thinking']}
+                elif dt == 'signature_delta':
+                    b['signature'] = b.get('signature', '') + d['signature']
+                elif dt == 'input_json_delta':
+                    b['_json'] += d.get('partial_json', '')
+            elif t == 'content_block_stop':
+                b = blocks.pop(ev['index'], None)
+                if not b:
+                    continue
+                if b['type'] == 'text':
+                    yield {'type': 'part', 'part': {'type': 'text', 'text': b.get('text', '')}}
+                elif b['type'] == 'tool_use':
+                    try:
+                        args = json.loads(b['_json'] or '{}')
+                    except ValueError:
+                        args = {'_invalid_json': b['_json']}
+                    yield {'type': 'part', 'part': {'type': 'tool_call', 'id': b['id'], 'name': b['name'], 'args': args}}
+                else:   # thinking, redacted_thinking, fallback… : renvoyés tels quels au tour suivant
+                    yield {'type': 'part', 'part': {'type': 'raw', 'provider': self.kind, 'block': b}}
+            elif t == 'message_delta':
+                r = ev.get('delta', {}).get('stop_reason')
+                if r:
+                    stop = {'tool_use': 'tool_use', 'max_tokens': 'max_tokens', 'refusal': 'refusal'}.get(r, 'end')
+        yield {'type': 'stop', 'reason': stop}

livequill/adapters/base.py

@@ -0,0 +1,88 @@
+"""Interface commune des adaptateurs.
+
+Format interne des messages (indépendant du fournisseur) :
+  {"role": "user", "content": [{"type": "text", "text": ...}, {"type": "image", "media_type": ..., "data": <base64>}]}
+  {"role": "assistant", "content": [{"type": "text", "text": ...},
+                                    {"type": "tool_call", "id": ..., "name": ..., "args": {...}, "meta": {...}},
+                                    {"type": "raw", "provider": "anthropic", "block": {...}}]}
+  {"role": "tool", "results": [{"id": ..., "name": ..., "content": str, "is_error": bool}]}
+
+Un adaptateur transforme ce format en requête HTTP (build_request, pure donc testable),
+puis lit le flux de réponse (parse_stream) et produit des événements :
+  {"type": "delta", "text": ...}       texte affiché en direct
+  {"type": "thinking", "text": ...}    réflexion (si le fournisseur la renvoie)
+  {"type": "part", "part": {...}}      bloc terminé, ajouté au message assistant
+  {"type": "stop", "reason": "end" | "tool_use" | "max_tokens" | "refusal"}
+"""
+from ..config import api_key
+from ..net import HTTPError, Transport
+
+
+class ToolsUnsupported(Exception):
+    """Le modèle refuse les tool calls : l'agent repasse en mode texte."""
+
+
+class Adapter:
+    kind = ''            # identifiant du type de fournisseur
+    is_cli = False       # True : l'agent CLI fait lui-même la boucle et écrit les fichiers
+    default_base = ''
+
+    def __init__(self, conf, transport=None):
+        self.conf = conf
+        self.http = transport or Transport()
+
+    @property
+    def base(self):
+        return (self.conf.get('base_url') or self.default_base).rstrip('/')
+
+    @property
+    def key(self):
+        return api_key(self.conf)
+
+    # --- à fournir par chaque adaptateur ---------------------------------
+    def list_models(self):
+        """[{"id": str, "label": str, "meta": {...}}] — meta sert à calculer les capacités."""
+        raise NotImplementedError
+
+    def caps(self, model, meta=None):
+        """{"tools": bool, "vision": bool, "effort": [[valeur, libellé], ...] | None, "fast": bool}"""
+        return {'tools': True, 'vision': False, 'effort': None, 'fast': False}
+
+    def build_request(self, model, system, messages, tools, opts):
+        """-> (méthode, url, en-têtes, corps JSON)"""
+        raise NotImplementedError
+
+    def parse_stream(self, lines):
+        raise NotImplementedError
+
+    # --- commun ----------------------------------------------------------
+    def test(self):
+        models = self.list_models()
+        return f'{len(models)} modèle(s) disponible(s)', models
+
+    def chat(self, model, system, messages, tools, opts, job=None):
+        method, url, headers, body = self.build_request(model, system, messages, tools, opts)
+        try:
+            yield from self.parse_stream(self.http.lines(method, url, headers, body, job))
+        except HTTPError as e:
+            if tools and looks_like_no_tools(e.body):
+                raise ToolsUnsupported(e.body) from None
+            raise
+
+
+def looks_like_no_tools(body):
+    b = (body or '').lower()
+    return 'does not support tools' in b or 'tool use is not supported' in b or ('tools' in b and 'not supported' in b) \
+        or 'function calling is not enabled' in b
+
+
+EFFORT_LABELS = {'off': 'Désactivée', 'on': 'Activée', 'minimal': 'Minimal', 'low': 'Low', 'medium': 'Medium',
+                 'high': 'High', 'xhigh': 'Extra high', 'max': 'Max'}
+
+
+def levels(*vals):
+    return [[v, EFFORT_LABELS.get(v, v)] for v in vals]
+
+
+def text_of(content):
+    return ''.join(p.get('text', '') for p in content if p.get('type') == 'text')

livequill/adapters/cli.py

@@ -0,0 +1,245 @@
+"""Agents CLI déjà installés (Claude Code, Codex, Gemini CLI) : ils font leur propre boucle et écrivent les fichiers.
+
+Pont vers les applications desktop : Claude Desktop embarque Claude Code, ChatGPT (et l'app Codex) embarquent Codex.
+Sans CLI installée, on utilise l'agent de l'application, déjà connecté au compte de l'utilisateur."""
+import glob, json, os, re, shutil, subprocess
+
+from .base import Adapter, levels
+
+AGENTS = {
+    'claude': {'label': 'Claude Code', 'models': [('default', 'Par défaut (Claude Code)'), ('opus', 'Opus'), ('sonnet', 'Sonnet'), ('haiku', 'Haiku')],
+               'effort': levels('low', 'medium', 'high', 'xhigh', 'max')},
+    'codex': {'label': 'Codex', 'models': [('default', 'Par défaut (Codex)')], 'effort': levels('low', 'medium', 'high')},
+    'gemini': {'label': 'Gemini CLI', 'models': [('default', 'Par défaut (Gemini CLI)')], 'effort': None},
+}
+
+
+# Où les installeurs officiels posent ces CLI, au cas où LiveQuill est lancé avec un PATH réduit
+# (raccourci de bureau, service, autre session) qui ne contient pas ces dossiers.
+EXTRA_DIRS = ['~/.local/bin', '~/bin', '~/.npm-global/bin', '~/.bun/bin', '~/.volta/bin', '~/.cargo/bin',
+              '~/.claude/local', '/usr/local/bin', '/opt/homebrew/bin']
+
+
+# Agents embarqués dans les applications desktop (Linux puis macOS). Le dossier de version change à chaque mise à jour
+# de l'application : on cherche à chaque fois et on prend la version la plus récente.
+BUNDLED = {
+    'claude': [('Claude Desktop', '~/.config/Claude/claude-code/*/*/claude'),
+               ('Claude Desktop', '~/Library/Application Support/Claude/claude-code/*/*/claude')],
+    'codex': [('ChatGPT', '/usr/lib/chatgpt/resources/codex'),
+              ('ChatGPT', '/opt/ChatGPT/resources/codex'),
+              ('ChatGPT', '/Applications/ChatGPT.app/Contents/Resources/codex'),
+              ('ChatGPT', '~/Applications/ChatGPT.app/Contents/Resources/codex'),
+              ('Codex', '/Applications/Codex.app/Contents/Resources/codex'),
+              ('Codex', '~/Applications/Codex.app/Contents/Resources/codex')],
+}
+
+
+def _version_key(path):
+    return [int(n) for n in re.findall(r'\d+', path)]
+
+
+def locate(name):
+    """-> (chemin, application) : la CLI installée d'abord, sinon l'agent embarqué dans une application desktop."""
+    exe = shutil.which(name)
+    if exe:
+        return exe, None
+    for d in EXTRA_DIRS:
+        p = os.path.join(os.path.expanduser(d), name)
+        if os.path.isfile(p) and os.access(p, os.X_OK):
+            return p, None
+    for app, pattern in BUNDLED.get(name, []):
+        hits = [p for p in glob.glob(os.path.expanduser(pattern)) if os.path.isfile(p) and os.access(p, os.X_OK)]
+        if hits:
+            return max(hits, key=_version_key), app
+    return None, None
+
+
+def find(name):
+    return locate(name)[0]
+
+
+def detect():
+    return {name: find(name) for name in AGENTS}
+
+
+def detect_via():
+    """Application desktop qui fournit l'agent, quand ce n'est pas une CLI installée."""
+    return {name: locate(name)[1] for name in AGENTS}
+
+
+def codex_user_model():
+    """Le modèle de premier niveau de ~/.codex/config.toml (seule valeur reprise de la config ignorée)."""
+    path = os.path.join(os.environ.get('CODEX_HOME') or os.path.expanduser('~/.codex'), 'config.toml')
+    try:
+        with open(path, encoding='utf-8') as f:
+            for line in f:
+                if line.lstrip().startswith('['):
+                    break                       # fin des clés de premier niveau
+                m = re.match(r'\s*model\s*=\s*"([^"]+)"', line)
+                if m:
+                    return m.group(1)
+    except OSError:
+        pass
+    return None
+
+
+def logged_in(name, exe):
+    """True / False si l'agent sait le dire, None sinon (vieille version, commande inconnue)."""
+    try:
+        if name == 'claude':
+            out = subprocess.run([exe, 'auth', 'status', '--json'], capture_output=True, text=True, timeout=20)
+            return bool(json.loads(out.stdout).get('loggedIn')) if out.stdout.strip().startswith('{') else None
+        if name == 'codex':
+            out = subprocess.run([exe, 'login', 'status'], capture_output=True, text=True, timeout=20)
+            text = (out.stdout + out.stderr).lower()
+            return True if 'logged in' in text and 'not logged in' not in text else (False if 'not logged in' in text else None)
+    except (OSError, ValueError, subprocess.SubprocessError):
+        return None
+    return None
+
+
+class CLIAdapter(Adapter):
+    kind = 'cli'
+    is_cli = True
+
+    @property
+    def agent(self):
+        return self.conf.get('command', 'claude')
+
+    def list_models(self):
+        a = AGENTS[self.agent]
+        extra = [m.strip() for m in (self.conf.get('extra_models') or '').split(',') if m.strip()]
+        return [{'id': i, 'label': l, 'meta': {}} for i, l in a['models']] + [{'id': m, 'label': m, 'meta': {}} for m in extra]
+
+    def caps(self, model, meta=None):
+        return {'tools': True, 'vision': self.agent in ('claude', 'codex'), 'effort': AGENTS[self.agent]['effort'], 'fast': False}
+
+    def test(self):
+        exe, app = locate(self.agent)
+        label = AGENTS[self.agent]['label']
+        if not exe:
+            raise RuntimeError(f'« {self.agent} » est introuvable : installe la CLI, ou l’application '
+                               f'{"Claude Desktop" if self.agent == "claude" else "ChatGPT" if self.agent == "codex" else "officielle"}')
+        if logged_in(self.agent, exe) is False:
+            how = f'ouvre l’application {app} et connecte-toi' if app else ('lance « claude auth login »' if self.agent == 'claude' else 'lance « codex login »')
+            raise RuntimeError(f'{label} n’est pas connecté à ton compte : {how}, puis reteste')
+        out = subprocess.run([exe, '--version'], capture_output=True, text=True, timeout=20)
+        version = (out.stdout or out.stderr).strip()[:80]
+        return f'{label} trouvé{f" (via l’app {app})" if app else ""} : {version}', self.list_models()
+
+    def command(self, root, model, opts, images, prompt=''):
+        """-> (argv, texte envoyé sur stdin). Le prompt passe par stdin : pas de limite de taille d'argument."""
+        exe = find(self.agent) or self.agent
+        m = None if model in (None, '', 'default') else model
+        e = opts.get('effort')
+        if self.agent == 'claude':
+            # --restricted : outils de fichiers confinés au dossier du projet, aucun outil qui exécute du code,
+            # réglages utilisateur/projet ignorés (hooks compris) ; --strict-mcp-config : aucun serveur MCP de l'utilisateur
+            argv = [exe, '-p', '--output-format', 'stream-json', '--verbose', '--include-partial-messages',
+                    '--restricted', '--strict-mcp-config', '--tools', 'Read,Edit,Write,Glob,Grep',
+                    '--permission-mode', 'acceptEdits', '--no-session-persistence',
+                    '--disallowedTools', 'Bash', 'WebFetch', 'WebSearch', 'Read(./.env*)', 'Edit(./.env*)', 'Write(./.env*)',
+                    '--allowedTools', 'Read', 'Edit', 'Write', 'Glob', 'Grep']
+            if m:
+                argv += ['--model', m]
+            if e:
+                argv += ['--effort', e]
+            return argv
+        if self.agent == 'codex':
+            # --ignore-user-config : ni les serveurs MCP ni les dossiers inscriptibles ajoutés dans ~/.codex/config.toml
+            # (un serveur MCP tourne hors de la sandbox) ; la connexion au compte reste celle de CODEX_HOME
+            # Sans la config utilisateur, on fixe nous-mêmes : jamais d'approbation demandée (impossible en non
+            # interactif ; les commandes restent dans la sandbox) et pas de réseau.
+            argv = [exe, 'exec', '--json', '--sandbox', 'workspace-write', '--ignore-user-config',
+                    '-c', 'approval_policy="never"', '-c', 'sandbox_workspace_write.network_access=false',
+                    '--cd', root, '--skip-git-repo-check', '--ephemeral']
+            m = m or codex_user_model()          # « Par défaut » garde le modèle choisi dans ~/.codex/config.toml
+            if m:
+                argv += ['--model', m]
+            if e:
+                argv += ['-c', f'model_reasoning_effort="{e}"']
+            if images:
+                argv += ['--image'] + images     # en dernier : l'option prend plusieurs valeurs
+            return argv
+        argv = [exe, '--approval-mode', 'auto_edit']
+        if m:
+            argv += ['-m', m]
+        return argv + ['-p', prompt]   # non vérifié : gemini n'est pas installé sur la machine de dev
+
+    def run(self, job, root, prompt, model, opts, images, emit):
+        argv = self.command(root, model, opts, images, prompt)
+        env = dict(os.environ, NO_COLOR='1')
+        if os.path.isabs(argv[0]):     # trouvé hors du PATH : ses outils voisins (node…) doivent rester accessibles
+            env['PATH'] = os.pathsep.join([os.path.dirname(argv[0]), env.get('PATH', '')])
+        p = subprocess.Popen(argv, cwd=root, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE,
+                             text=True, bufsize=1, env=env)
+        job.on_cancel(p.kill)
+        p.stdin.write('' if self.agent == 'gemini' else prompt)
+        p.stdin.close()
+        final = []
+        for ln in p.stdout:
+            for ev in self.parse_line(ln.rstrip('\n')):
+                if ev['type'] == 'final':
+                    final = [ev['text']]
+                else:
+                    if ev['type'] == 'delta':
+                        final.append(ev['text'])
+                    emit(ev)
+        err = p.stderr.read()
+        code = p.wait()
+        if code and not job.cancelled:
+            raise RuntimeError(f'{self.agent} a échoué (code {code}) : {err.strip()[-600:]}')
+        return ''.join(final).strip()
+
+    def parse_line(self, ln):
+        if self.agent == 'gemini':
+            return [{'type': 'delta', 'text': ln + '\n'}] if ln else []
+        try:
+            ev = json.loads(ln)
+        except ValueError:
+            return []
+        return (parse_claude if self.agent == 'claude' else parse_codex)(ev)
+
+
+def tool_summary(name, inp):
+    path = inp.get('file_path') or inp.get('path') or inp.get('pattern') or ''
+    return {'type': 'tool', 'name': name, 'summary': f'{name} {path}'.strip(), 'path': path}
+
+
+def parse_claude(ev):
+    t = ev.get('type')
+    if t == 'stream_event':
+        e = ev.get('event') or {}
+        d = e.get('delta') or {}
+        if e.get('type') == 'content_block_delta' and d.get('type') == 'text_delta':
+            return [{'type': 'delta', 'text': d['text']}]
+        if e.get('type') == 'content_block_delta' and d.get('type') == 'thinking_delta':
+            return [{'type': 'thinking', 'text': d['thinking']}]
+        return []
+    if t == 'assistant':
+        return [tool_summary(b['name'], b.get('input') or {}) for b in (ev.get('message') or {}).get('content', [])
+                if b.get('type') == 'tool_use']
+    if t == 'result':
+        if ev.get('is_error'):
+            raise RuntimeError(str(ev.get('result') or ev.get('subtype')))
+        return [{'type': 'final', 'text': ev.get('result') or ''}]
+    return []
+
+
+def parse_codex(ev):
+    t = ev.get('type', '')
+    if t in ('error', 'turn.failed'):
+        raise RuntimeError(str(ev.get('message') or ev.get('error') or ev))
+    if t != 'item.completed':
+        return []
+    it = ev.get('item') or {}
+    k = it.get('type') or it.get('item_type')
+    if k in ('agent_message', 'assistant_message'):
+        return [{'type': 'delta', 'text': (it.get('text') or '') + '\n'}]
+    if k == 'reasoning':
+        return [{'type': 'thinking', 'text': it.get('text') or ''}]
+    if k == 'file_change':
+        return [{'type': 'tool', 'name': 'edit', 'summary': f'edit {c.get("path")}', 'path': c.get('path')} for c in it.get('changes') or []]
+    if k == 'command_execution':
+        return [{'type': 'tool', 'name': 'shell', 'summary': f'$ {it.get("command")}'}]
+    return []