c’est possible :

• Le softphone Twilio (Voice JS SDK) côté agent humain peut afficher, en plus de l’écran d’appel, des données issues de votre Odoo CRM.

• • • • Techniquement, il suffit que le softphone appelle un petit backend CTI qui interroge Odoo via JSON-RPC / XML-RPC / REST et lui renvoie les infos utiles (contact, opportunité, historique, notes…).
      • Ce backend peut aussi écrire dans Odoo (log d’appel, création d’activité, rattachement à un contact).

2) React (Agent) — Voice JS SDK + Screen-pop Odoo

// AgentSoftphone.jsx
import React, { useEffect, useRef, useState } from "react";
import { Device } from "@twilio/voice-sdk";

/**
 * Conditions :
 * - Vous exposez /token?identity=support-agent (backend qui délivre un AccessToken Twilio)
 * - Vous exposez /api/odoo/contacts/lookup?phone=... (backend CTI → Odoo JSON-RPC)
 */

export default function AgentSoftphone() {
  const [status, setStatus] = useState("déconnecté");
  const [contact, setContact] = useState(null); // objet Odoo à afficher
  const deviceRef = useRef(null);
  const activeCallRef = useRef(null);

  const connect = async () => {
    if (deviceRef.current) return;
    setStatus("connexion…");
    const r = await fetch(`/token?identity=${encodeURIComponent("support-agent")}`);
    const { token } = await r.json();

    const dev = new Device(token, {
      codecPreferences: ["opus", "pcmu"],
      allowIncomingWhileBusy: true,
    });

    // Appels entrants
    dev.on("incoming", async (call) => {
      setStatus("appel entrant…");

      // 1) Récupérer les paramètres TwiML passés dans <Client><Parameter>
      const phone =
        call.parameters?.From || call.customParameters?.get("customer_phone") || "";

      // 2) Screen-pop Odoo
      if (phone) {
        try {
          const resp = await fetch(
            `/api/odoo/contacts/lookup?phone=${encodeURIComponent(phone)}`
          );
          const data = await resp.json();
          setContact((data.matches && data.matches[0]) || null);
        } catch (e) {
          console.error("Lookup Odoo failed", e);
        }
      }

      // 3) Gérer le call
      call.on("accept", () => setStatus("en communication"));
      call.on("disconnect", () => {
        setStatus("terminé");
        activeCallRef.current = null;
      });
      call.accept(); // auto-accept MVP
      activeCallRef.current = call;
    });

    dev.on("registered", () => setStatus("enregistré (support-agent)"));
    dev.on("error", (e) => setStatus(`erreur: ${e.message}`));

    await dev.register();
    deviceRef.current = dev;
  };

  const hangup = () => {
    activeCallRef.current?.disconnect();
    activeCallRef.current = null;
  };

  useEffect(() => {
    return () => {
      activeCallRef.current?.disconnect();
      deviceRef.current?.unregister();
      deviceRef.current?.destroy();
    };
  }, []);

  return (
    <div style={{ maxWidth: 840, margin: "24px auto", fontFamily: "system-ui" }}>
      <h2>Console Agent – Softphone Twilio</h2>
      <div style={{ display: "flex", gap: 8, margin: "8px 0" }}>
        <button onClick={connect}>Se connecter</button>
        <span style={{ opacity: 0.75 }}>{status}</span>
        <button onClick={hangup} style={{ marginLeft: "auto" }}>
          Raccrocher
        </button>
      </div>

      <div style={{ display: "grid", gridTemplateColumns: "2fr 1fr", gap: 12 }}>
        <div style={{ border: "1px solid #eee", borderRadius: 12, padding: 12 }}>
          <h3>État de l’appel</h3>
          <p>La carte softphone (boutons, timer, etc.) peut être ici.</p>
          <p style={{ fontSize: 12, color: "#666" }}>
            Astuce : si vous passez aussi un <code>lead_id</code> en Parameter,
            vous pouvez précharger l’opportunité Odoo en parallèle.
          </p>
        </div>

        <div style={{ border: "1px solid #eee", borderRadius: 12, padding: 12 }}>
          <h3>Screen-pop Odoo (contact)</h3>
          {contact ? (
            <div>
              <div style={{ fontWeight: 600 }}>{contact.name}</div>
              <div style={{ fontSize: 14 }}>
                {contact.email || "—"} · {contact.phone || contact.mobile || "—"}
              </div>
              <div style={{ marginTop: 8 }}>
                <a
                  href={`https://votre-odoo/res_partner/${contact.id}`}
                  target="_blank"
                  rel="noreferrer"
                >
                  Ouvrir dans Odoo
                </a>
              </div>
            </div>
          ) : (
            <div style={{ fontSize: 14, color: "#666" }}>Aucun contact trouvé.</div>
          )}
        </div>
      </div>
    </div>
  );
}

2) Module Odoo minimal (REST) — lookup contact par téléphone

Objectif : exposer un endpoint HTTP REST côté Odoo pour rechercher un contact (res.partner) à partir d’un numéro, de façon sécurisée.

Structure du module

odoo_addons/
  cti_partner_api/
    __manifest__.py
    __init__.py
    controllers/
      __init__.py
      partner_api.py

__manifest__.py

{
    "name": "CTI Partner API",
    "version": "16.0.1.0.0",
    "summary": "Endpoints REST pour lookup contact (CTI)",
    "depends": ["base", "contacts"],
    "data": [],
    "installable": True,
    "application": False,
    "license": "LGPL-3",
}

__init__.py

from . import controllers

controllers/__init__.py

from . import partner_api

controllers/partner_api.py

# -*- coding: utf-8 -*-
from odoo import http
from odoo.http import request
import re
import json

def _normalize_phone(raw):
    if not raw:
        return ""
    s = re.sub(r"[^\d+]", "", str(raw))
    # FR: 0XXXXXXXXX -> +33XXXXXXXXX
    if s.startswith("0") and len(s) == 10:
        s = "+33" + s[1:]
    return s

def _auth_api_key(req):
    """
    Auth très simple par clé API envoyée en header:
      Authorization: Bearer <API_KEY>
    À remplacer par OAuth/SSO si besoin.
    """
    h = req.httprequest.headers.get("Authorization", "")
    if h.startswith("Bearer "):
        token = h[7:].strip()
        # Compare avec la clé stockée en param système (ou env)
        api_key = request.env["ir.config_parameter"].sudo().get_param("cti_partner_api.key")
        return token and api_key and token == api_key
    return False

class PartnerAPI(http.Controller):
    @http.route("/odoo/api/partners/lookup", type="http", auth="public", methods=["GET"], csrf=False)
    def partners_lookup(self, **params):
        # Auth simple
        if not _auth_api_key(request):
            return request.make_response(json.dumps({"error": "unauthorized"}), headers=[("Content-Type", "application/json")], status=401)

        phone = _normalize_phone(params.get("phone"))
        limit = int(params.get("limit", 5))

        env = request.env["res.partner"].sudo()

        domain = ["|", ("phone", "=", phone), ("mobile", "=", phone)]
        fields = ["id", "name", "email", "phone", "mobile", "company_type"]
        partners = env.search_read(domain, fields, limit=limit)

        # Fallback "contient" si pas trouvé
        if not partners and phone:
            last7 = phone[-7:]
            domain2 = ["|", ("phone", "ilike", last7), ("mobile", "ilike", last7)]
            partners = env.search_read(domain2, fields, limit=limit)

        return request.make_response(json.dumps({"matches": partners}), headers=[("Content-Type", "application/json")], status=200)