Fix

agent.py

@@ -1,43 +1,50 @@
-from smolagent import SmolAgent, OpenAIProvider
-from smolagent.schema import ChatPrompt, Prompt
-
-# Crée le système de prompt soigné pour générer email professionnel
-system_prompt = Prompt(
-    role="system",
-    content=(
-        "Tu es un assistant IA qui génère des emails professionnels adaptés au contexte, "
-        "au destinataire et au ton donné. "
-        "Rédige d’abord un objet court et pertinent, puis le corps du mail complet."
-    ),
+from smolagents import tool, CodeAgent, InferenceClientModel, FinalAnswerTool
+
+# Définition de l'outil : écrire un email formel, chaleureux, etc.
+@tool
+def write_email(to: str, context: str, tone: str) -> tuple[str, str]:
+    """Génère un objet et un corps d'email à destination de quelqu'un dans un certain ton."""
+    # La génération sera assurée par le LLM via le prompt, rien n'est codé ici
+    pass
+
+# Chargement du modèle
+model = InferenceClientModel(
+    model_id="Qwen/Qwen2.5-7B-Instruct",
+    temperature=0.5,
+    max_tokens=2048
 )
 
-# Prompt utilisateur (input)
-user_prompt = Prompt(
-    role="user",
-    content=(
-        "Destinataire : {to_email}\n"
-        "Contexte : {context}\n"
-        "Ton souhaité : {tone}\n\n"
-        "Génère un objet et un corps d'email."
-    ),
+# Définition de l'agent
+agent = CodeAgent(
+    model=model,
+    tools=[write_email, FinalAnswerTool()],
+    max_steps=5,
+    verbosity_level=1,
 )
 
 def build_email_agent():
-    provider = OpenAIProvider(model="gpt-4o-mini")  # ou autre modèle disponible
-    prompt = ChatPrompt(prompts=[system_prompt, user_prompt])
-    agent = SmolAgent(provider=provider, prompt=prompt)
     return agent
 
-def generate_email(agent, to_email, context, tone):
-    # Formate le prompt avec les valeurs utilisateur
-    inputs = {
-        "to_email": to_email,
-        "context": context,
-        "tone": tone,
-    }
-    response = agent.chat(inputs)
-    # La réponse devrait contenir objet + corps, on sépare à la première ligne vide
-    parts = response.strip().split('\n\n', 1)
-    subject = parts[0].strip() if parts else "Objet automatique"
-    body = parts[1].strip() if len(parts) > 1 else response.strip()
+# Génération du mail avec appel à l'agent
+def generate_email(agent, to_email: str, context: str, tone: str) -> tuple[str, str]:
+    prompt = f"""Tu es un assistant virtuel. Rédige un email destiné à {to_email}.
+
+Contexte : {context}
+Ton : {tone}
+
+Réponds en deux parties :
+1. Objet : ligne d'objet de l'email
+2. Corps : contenu de l'email bien rédigé, en respectant le ton demandé.
+Commence chaque partie par son étiquette.
+"""
+    result = agent.chat(prompt)
+
+    # Extraction simple de l'objet et du corps
+    subject, body = "Sans objet", result.strip()
+    for line in result.splitlines():
+        if line.lower().startswith("objet"):
+            subject = line.split(":", 1)[-1].strip()
+            body = result.split(line, 1)[-1].replace(line, "").strip()
+            break
+
     return subject, body

app.py

@@ -8,17 +8,19 @@ def on_generate(to_email, context, tone):
     subject, body = generate_email(agent, to_email, context, tone)
     return subject, body
 
-def on_send(to_email, subject, body):
-    success, message = send_email(to_email, subject, body)
+def on_send(sender_email, to_email, subject, body):
+    success, message = send_email(sender_email, to_email, subject, body)
     return message
 
 with gr.Blocks(title="Assistant Email Pro avec SmolAgent") as demo:
     gr.Markdown("# ✉️ Assistant Email Professionnel SmolAgent")
 
+    sender = gr.Textbox(label="Expéditeur (adresse Gmail utilisée)")
     to_email = gr.Textbox(label="Destinataire", placeholder="exemple@exemple.com")
     context = gr.Textbox(label="Contexte ou objectif", lines=4,
                          placeholder="Demander un rendez-vous, relancer un client...")
-    tone = gr.Dropdown(choices=["Formel", "Chaleureux", "Direct", "Poli"], value="Formel", label="Ton")
+    tone = gr.Dropdown(choices=["Formel", "Chaleureux", "Direct", "Poli"],
+                       value="Formel", label="Ton")
 
     subject = gr.Textbox(label="Objet de l'email")
     body = gr.Textbox(label="Corps de l'email", lines=10)
@@ -30,6 +32,6 @@ with gr.Blocks(title="Assistant Email Pro avec SmolAgent") as demo:
     status = gr.Markdown()
 
     generate_btn.click(on_generate, inputs=[to_email, context, tone], outputs=[subject, body])
-    send_btn.click(on_send, inputs=[to_email, subject, body], outputs=status)
+    send_btn.click(on_send, inputs=[sender, to_email, subject, body], outputs=status)
 
 demo.launch()

email_sender.py

@@ -6,38 +6,49 @@ from google_auth_oauthlib.flow import InstalledAppFlow
 from google.auth.transport.requests import Request
 from googleapiclient.discovery import build
 
-TOKEN_PATH = "token.pkl"
+SCOPES = ["https://www.googleapis.com/auth/gmail.send"]
 CREDENTIALS_PATH = "client_secret.json"
 
+# Stocker les tokens par email utilisateur
+def get_token_path(sender_email):
+    safe_email = sender_email.replace("@", "_at_").replace(".", "_dot_")
+    return f"token_{safe_email}.pkl"
+
+# Écrire le client secret s'il est fourni par variable d'env
 client_secret_content = os.getenv("CLIENT_SECRET_JSON")
 if client_secret_content and not os.path.exists(CREDENTIALS_PATH):
     with open(CREDENTIALS_PATH, "w") as f:
         f.write(client_secret_content)
 
-def authenticate_gmail():
-    SCOPES = ["https://www.googleapis.com/auth/gmail.send"]
+def authenticate_gmail(sender_email: str):
     creds = None
-    if os.path.exists(TOKEN_PATH):
-        with open(TOKEN_PATH, "rb") as token:
+    token_path = get_token_path(sender_email)
+
+    if os.path.exists(token_path):
+        with open(token_path, "rb") as token:
             creds = pickle.load(token)
+
     if not creds or not creds.valid:
         if creds and creds.expired and creds.refresh_token:
             creds.refresh(Request())
         else:
             flow = InstalledAppFlow.from_client_secrets_file(CREDENTIALS_PATH, SCOPES)
             creds = flow.run_local_server(port=0)
-        with open(TOKEN_PATH, "wb") as token:
+        with open(token_path, "wb") as token:
             pickle.dump(creds, token)
-    service = build("gmail", "v1", credentials=creds)
-    return service
 
-def send_email(to_email, subject, body):
-    service = authenticate_gmail()
+    return build("gmail", "v1", credentials=creds)
+
+def send_email(sender_email: str, to_email: str, subject: str, body: str):
+    service = authenticate_gmail(sender_email)
+
     message = MIMEText(body)
     message["to"] = to_email
     message["subject"] = subject
+    message["from"] = sender_email
     raw_message = base64.urlsafe_b64encode(message.as_bytes()).decode()
     send_message = {"raw": raw_message}
+
     try:
         sent = service.users().messages().send(userId="me", body=send_message).execute()
         return True, f"✅ Email envoyé à {to_email} (ID: {sent['id']})"

requirements.txt

@@ -1,5 +1,5 @@
 markdownify
-git+https://github.com/jtmuller5/smol-agent.git
+smolagents==1.13.0
 requests
 duckduckgo_search
 pandas