intermesh 0.4.1__tar.gz → 0.4.2__tar.gz

{intermesh-0.4.1 → intermesh-0.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: intermesh
-Version: 0.4.1
+Version: 0.4.2
 Summary: Universal coordination protocol for AI agents — E2E encrypted, cross-language, federated
 Author: InterMesh Protocol Authors
 License: Apache-2.0
@@ -78,19 +78,26 @@ asyncio.run(main())
 **Delegate work from an orchestrator:**
 
 ```python
+import asyncio
 from intermesh import InterMeshAgent
 
-orchestrator = InterMeshAgent(name="lead", roles=["admin"])
-await orchestrator.connect()
+# `await` is not valid at module level in Python, so this lives in a
+# coroutine. Copy-pasting it without the wrapper is a SyntaxError, not a
+# runtime error — it fails before anything runs.
+async def main():
+    orchestrator = InterMeshAgent(name="lead", roles=["admin"])
+    await orchestrator.connect()
+
+    # Find an agent by capability, then hand it a task
+    found = await orchestrator.discover(capabilities=["calculate"])
+    result = await orchestrator.submit_task(
+        title="Add two numbers",
+        assignee=found["agents"][0]["name"],
+        input_data={"a": 20, "b": 22},
+    )
+    print(result)   # {"result": 42} — encrypted end-to-end in transit
 
-# Find an agent by capability, then hand it a task
-found = await orchestrator.discover(capabilities=["calculate"])
-result = await orchestrator.submit_task(
-    title="Add two numbers",
-    assignee=found["agents"][0]["name"],
-    input_data={"a": 20, "b": 22},
-)
-# {"result": 42}  — encrypted end-to-end in transit
+asyncio.run(main())
 ```
 
 ---
@@ -106,7 +113,7 @@ A LangChain runnable:
 from intermesh import from_langchain
 
 agent = from_langchain(my_chain, name="analyst", capabilities=["market_analysis"])
-await agent.connect()
+agent.run()          # connects, then stays in service
 ```
 
 Anything else — a CrewAI crew, an AutoGen agent, a LlamaIndex engine, or a
@@ -122,7 +129,7 @@ async def run(data):
     return await asyncio.to_thread(lambda: my_crew.kickoff(inputs=data))
 
 agent = from_callable(run, name="research", capabilities=["research"])
-await agent.connect()
+agent.run()
 ```
 
 Or as a decorator:

{intermesh-0.4.1 → intermesh-0.4.2}/README.md

@@ -47,19 +47,26 @@ asyncio.run(main())
 **Delegate work from an orchestrator:**
 
 ```python
+import asyncio
 from intermesh import InterMeshAgent
 
-orchestrator = InterMeshAgent(name="lead", roles=["admin"])
-await orchestrator.connect()
+# `await` is not valid at module level in Python, so this lives in a
+# coroutine. Copy-pasting it without the wrapper is a SyntaxError, not a
+# runtime error — it fails before anything runs.
+async def main():
+    orchestrator = InterMeshAgent(name="lead", roles=["admin"])
+    await orchestrator.connect()
+
+    # Find an agent by capability, then hand it a task
+    found = await orchestrator.discover(capabilities=["calculate"])
+    result = await orchestrator.submit_task(
+        title="Add two numbers",
+        assignee=found["agents"][0]["name"],
+        input_data={"a": 20, "b": 22},
+    )
+    print(result)   # {"result": 42} — encrypted end-to-end in transit
 
-# Find an agent by capability, then hand it a task
-found = await orchestrator.discover(capabilities=["calculate"])
-result = await orchestrator.submit_task(
-    title="Add two numbers",
-    assignee=found["agents"][0]["name"],
-    input_data={"a": 20, "b": 22},
-)
-# {"result": 42}  — encrypted end-to-end in transit
+asyncio.run(main())
 ```
 
 ---
@@ -75,7 +82,7 @@ A LangChain runnable:
 from intermesh import from_langchain
 
 agent = from_langchain(my_chain, name="analyst", capabilities=["market_analysis"])
-await agent.connect()
+agent.run()          # connects, then stays in service
 ```
 
 Anything else — a CrewAI crew, an AutoGen agent, a LlamaIndex engine, or a
@@ -91,7 +98,7 @@ async def run(data):
     return await asyncio.to_thread(lambda: my_crew.kickoff(inputs=data))
 
 agent = from_callable(run, name="research", capabilities=["research"])
-await agent.connect()
+agent.run()
 ```
 
 Or as a decorator:

{intermesh-0.4.1 → intermesh-0.4.2}/intermesh/__init__.py

@@ -1,4 +1,4 @@
-from intermesh.agent import InterMeshAgent
+from intermesh.agent import InterMeshAgent, EncryptionMismatch
 from intermesh.message import MessageType, InterMeshMessage
 from intermesh.identity import AgentIdentity
 from intermesh.task import InterMeshTask, TaskStatus
@@ -53,4 +53,4 @@ try:
 except ImportError:
     pass
 
-__version__ = "0.4.1"
+__version__ = "0.4.2"

{intermesh-0.4.1 → intermesh-0.4.2}/intermesh/agent.py

@@ -10,8 +10,17 @@ import websockets
 from intermesh.message import MessageType, InterMeshMessage
 from intermesh.identity import AgentIdentity
 from intermesh.task import InterMeshTask, TaskStatus
-from intermesh.crypto import generate_keypair, get_public_key_pem, encrypt_for, decrypt_with
+from intermesh.crypto import (generate_keypair, get_public_key_pem, encrypt_for,
+                             decrypt_with, looks_encrypted)
 from intermesh.egress import EgressPolicy, apply_egress
+
+
+class EncryptionMismatch(ValueError):
+    """Les deux côtés ne s'accordent pas sur le chiffrement.
+
+    Levée plutôt que de rendre du texte chiffré à un gestionnaire, qui le
+    traiterait comme des données et rendrait un résultat faux.
+    """
 from intermesh.schema import SchemaRegistry, default_registry
 
 
@@ -329,10 +338,41 @@ class InterMeshAgent:
             decrypted = decrypt_with(self._private_key, encrypted_content)
             try: return json.loads(decrypted)
             except json.JSONDecodeError: return decrypted
-        except Exception:
+        except Exception as exc:
+            # Une charge reconnaissable comme chiffrée mais qu'on n'arrive pas
+            # à ouvrir n'est pas une chaîne ordinaire : la rendre telle quelle
+            # la ferait traiter comme des données.
+            if looks_encrypted(encrypted_content):
+                raise EncryptionMismatch(
+                    "Charge chiffrée illisible : elle a été chiffrée pour une autre "
+                    "clé publique que celle de cet agent. Un agent qui se reconnecte "
+                    "sous le même nom change de clé ; l'émetteur doit alors la "
+                    "redemander (WHO_IS) avant de chiffrer."
+                ) from exc
             try: return json.loads(encrypted_content)
             except json.JSONDecodeError: return encrypted_content
 
+    def _unwrap_incoming(self, value, what: str):
+        """Rend la charge exploitable, ou refuse franchement.
+
+        Le piège que ceci ferme : avec `encrypt=False`, aucun déchiffrement
+        n'était tenté et le texte chiffré arrivait tel quel au gestionnaire,
+        qui le traitait comme des données. La tâche « réussissait » et
+        rendait un résultat faux — le pire mode de défaillance pour un
+        produit dont l'argument est le chiffrement de bout en bout.
+        """
+        if self.encrypt:
+            return self._decrypt_content(value) if isinstance(value, str) else value
+
+        if looks_encrypted(value):
+            raise EncryptionMismatch(
+                f"{what} chiffré reçu alors que le chiffrement est désactivé sur cet "
+                f"agent (encrypt=False). Activez-le ici, ou désactivez-le chez "
+                f"l'émetteur : les deux côtés doivent s'accorder. Sans ce refus, le "
+                f"texte chiffré serait traité comme des données."
+            )
+        return value
+
     async def _respond_to_request(self, msg) -> None:
         """Exécute le gestionnaire de requêtes et renvoie la réponse.
 
@@ -410,8 +450,7 @@ class InterMeshAgent:
                         asyncio.create_task(self._respond_to_request(msg))
 
                 elif msg.type == MessageType.MESSAGE:
-                    content = msg.content
-                    if self.encrypt and isinstance(content, str): content = self._decrypt_content(content)
+                    content = self._unwrap_incoming(msg.content, "Message")
                     msg.content = content
                     if self._message_handler:
                         if inspect.iscoroutinefunction(self._message_handler): await self._message_handler(msg)
@@ -448,11 +487,10 @@ class InterMeshAgent:
         task.update_status(TaskStatus.RUNNING)
         await self.ws.send(InterMeshMessage(type=MessageType.TASK_UPDATE, sender=self.qualified_name, content=task.to_dict(), token=self.token).to_json())
 
-        decrypted_input = task.input_data
-        if self.encrypt and isinstance(decrypted_input, str):
-            decrypted_input = self._decrypt_content(decrypted_input)
-
         try:
+            # Dans le bloc : un refus de déchiffrement doit rapporter la tâche
+            # en échec avec sa raison, pas remonter jusqu'à la boucle d'écoute.
+            decrypted_input = self._unwrap_incoming(task.input_data, "Contenu de tâche")
             if self._task_handler:
                 output = await self._task_handler(decrypted_input, task) if inspect.iscoroutinefunction(self._task_handler) else self._task_handler(decrypted_input, task)
             else:

{intermesh-0.4.1 → intermesh-0.4.2}/intermesh/cli.py

@@ -13,17 +13,23 @@ from intermesh.crypto import generate_keypair, get_public_key_pem
 from intermesh.identity import AgentIdentity
 
 
+# Le dessin vit dans une chaîne brute : ses antislashs sont des traits,
+# pas des séquences d'échappement. Les laisser dans une f-string produisait
+# un SyntaxWarning à chaque appel de la CLI — un avertissement affiché à
+# chaque commande coûte plus cher que le dessin ne rapporte.
+_LOGO = r"""    _____   __________________  __  ______________ __  __
+   /  _/ | / /_  __/ ____/ __ \/  |/  / ____/ ___// / / /
+   / //  |/ / / / / __/ / /_/ / /|_/ / __/  \__ \/ /_/ /
+ _/ // /|  / / / / /___/ _, _/ /  / / /___ ___/ / __  /
+/___/_/ |_/ /_/ /_____/_/ |_/_/  /_/_____//____/_/ /_/"""
+
+
 def print_banner():
     # La version vient du paquet : une chaîne en dur ici finit toujours
     # par mentir après quelques releases.
     from intermesh import __version__
-    print(f"""
-\033[36m    _   ___________  _______
-   / | / / ____/   |/  _/   |  INTERMESH PROTOCOL
-  /  |/ / __/ / /| |/ // /| |  Universal Agent Infrastructure
- / /|  / /___/ ___ / // ___ |  CLI Developer Tool v{__version__}
-/_/ |_/_____/_/  |_/___/_/  |_|\033[0m
-""")
+    print(f"\n\033[36m{_LOGO}\033[0m\n")
+    print(f"  Universal Agent Infrastructure · CLI v{__version__}\n")
 
 
 def run_security_check(args):

{intermesh-0.4.1 → intermesh-0.4.2}/intermesh/crypto.py

@@ -60,6 +60,31 @@ def encrypt_for(recipient_public_key_pem: str, plaintext: str) -> str:
     return base64.b64encode(json.dumps(envelope).encode()).decode()
 
 
+ENVELOPE_KEYS = {"ek", "n", "ct"}
+
+
+def looks_encrypted(value) -> bool:
+    """Reconnaît une charge produite par `encrypt_for`, sans la déchiffrer.
+
+    Sert à distinguer « cet agent reçoit du texte chiffré qu'il ne sait pas
+    ouvrir » de « cet agent reçoit une chaîne ordinaire ». Sans cette
+    distinction, un agent configuré sans chiffrement traitait le texte
+    chiffré comme des données : la tâche paraissait réussir et rendait un
+    résultat faux, ce qui est pire qu'un échec.
+
+    Le test est structurel — base64 d'un objet JSON portant exactement les
+    trois champs de l'enveloppe — et n'exige aucune clé. Une chaîne
+    ordinaire, même en base64, ne produit pas cette forme.
+    """
+    if not isinstance(value, str) or len(value) < 32:
+        return False
+    try:
+        envelope = json.loads(base64.b64decode(value, validate=True))
+    except Exception:
+        return False
+    return isinstance(envelope, dict) and set(envelope) == ENVELOPE_KEYS
+
+
 def decrypt_with(private_key, encrypted_b64: str) -> str:
     """Déchiffrement hybride RSA-OAEP + AES-256-GCM."""
     envelope = json.loads(base64.b64decode(encrypted_b64))

{intermesh-0.4.1 → intermesh-0.4.2}/intermesh.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: intermesh
-Version: 0.4.1
+Version: 0.4.2
 Summary: Universal coordination protocol for AI agents — E2E encrypted, cross-language, federated
 Author: InterMesh Protocol Authors
 License: Apache-2.0
@@ -78,19 +78,26 @@ asyncio.run(main())
 **Delegate work from an orchestrator:**
 
 ```python
+import asyncio
 from intermesh import InterMeshAgent
 
-orchestrator = InterMeshAgent(name="lead", roles=["admin"])
-await orchestrator.connect()
+# `await` is not valid at module level in Python, so this lives in a
+# coroutine. Copy-pasting it without the wrapper is a SyntaxError, not a
+# runtime error — it fails before anything runs.
+async def main():
+    orchestrator = InterMeshAgent(name="lead", roles=["admin"])
+    await orchestrator.connect()
+
+    # Find an agent by capability, then hand it a task
+    found = await orchestrator.discover(capabilities=["calculate"])
+    result = await orchestrator.submit_task(
+        title="Add two numbers",
+        assignee=found["agents"][0]["name"],
+        input_data={"a": 20, "b": 22},
+    )
+    print(result)   # {"result": 42} — encrypted end-to-end in transit
 
-# Find an agent by capability, then hand it a task
-found = await orchestrator.discover(capabilities=["calculate"])
-result = await orchestrator.submit_task(
-    title="Add two numbers",
-    assignee=found["agents"][0]["name"],
-    input_data={"a": 20, "b": 22},
-)
-# {"result": 42}  — encrypted end-to-end in transit
+asyncio.run(main())
 ```
 
 ---
@@ -106,7 +113,7 @@ A LangChain runnable:
 from intermesh import from_langchain
 
 agent = from_langchain(my_chain, name="analyst", capabilities=["market_analysis"])
-await agent.connect()
+agent.run()          # connects, then stays in service
 ```
 
 Anything else — a CrewAI crew, an AutoGen agent, a LlamaIndex engine, or a
@@ -122,7 +129,7 @@ async def run(data):
     return await asyncio.to_thread(lambda: my_crew.kickoff(inputs=data))
 
 agent = from_callable(run, name="research", capabilities=["research"])
-await agent.connect()
+agent.run()
 ```
 
 Or as a decorator:

{intermesh-0.4.1 → intermesh-0.4.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "intermesh"
-version = "0.4.1"
+version = "0.4.2"
 description = "Universal coordination protocol for AI agents — E2E encrypted, cross-language, federated"
 readme = "README.md"
 license = {text = "Apache-2.0"}