meshcore 2.1.21__tar.gz → 2.2.6__tar.gz

{meshcore-2.1.21 → meshcore-2.2.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: meshcore
-Version: 2.1.21
+Version: 2.2.6
 Summary: Base classes for communicating with meshcore companion radios
 Project-URL: Homepage, https://github.com/fdlamotte/meshcore_py
 Project-URL: Issues, https://github.com/fdlamotte/meshcore_py/issues
@@ -12,7 +12,7 @@ Classifier: Programming Language :: Python :: 3
 Requires-Python: >=3.10
 Requires-Dist: bleak
 Requires-Dist: pycayennelpp
-Requires-Dist: pyserial-asyncio
+Requires-Dist: pyserial-asyncio-fast
 Provides-Extra: dev
 Requires-Dist: black; extra == 'dev'
 Requires-Dist: pytest; extra == 'dev'
@@ -490,6 +490,8 @@ All events in MeshCore are represented by the `EventType` enum. These events are
 | `LOG_DATA` | `"log_data"` | Generic log data | Various log information |
 | **Binary Protocol Events** |||
 | `BINARY_RESPONSE` | `"binary_response"` | Generic binary response | Tag and hex data |
+| `SIGN_START` | `"sign_start"` | Start of an on-device signing session | Maximum buffer size (bytes) for data to sign |
+| `SIGNATURE` | `"signature"` | Resulting on-device signature | Raw signature bytes |
 | **Authentication Events** |||
 | `LOGIN_SUCCESS` | `"login_success"` | Successful login | Permissions, admin status, pubkey prefix |
 | `LOGIN_FAILED` | `"login_failed"` | Failed login attempt | Pubkey prefix |
@@ -539,6 +541,13 @@ All commands are async methods that return `Event` objects. Commands are organiz
 | `reboot()` | None | None | Reboot device (no response expected) |
 | **Security** ||||
 | `export_private_key()` | None | `PRIVATE_KEY/DISABLED` | Export device private key (requires PIN auth & enabled firmware) |
+| `import_private_key(key)` | `key: bytes` | `OK` | Import private key to device |
+| **Statistics** ||||
+| `get_stats_core()` | None | `STATS_CORE` | Get core statistics (voltage, uptime, errors, queue length) |
+| `get_stats_radio()` | None | `STATS_RADIO` | Get radio statistics (noise floor, last RSSI/SNR, tx/rx time stats) |
+| `get_stats_packets()` | None | `STATS_PACKETS` | Get packet statistics (rx/tx totals, flood vs. direct, recv_errors when present) |
+| **Advanced Configuration** ||||
+| `set_multi_acks(multi_acks)` | `multi_acks: int` | `OK` | Set multi-acks mode (experimental ack repeats) |
 
 #### Contact Commands (`meshcore.commands.*`)
 
@@ -566,7 +575,7 @@ All commands are async methods that return `Event` objects. Commands are organiz
 | `get_msg(timeout=None)` | `timeout: float` | `CONTACT_MSG_RECV/CHANNEL_MSG_RECV/NO_MORE_MSGS` | Get next pending message |
 | `send_msg(dst, msg, timestamp=None)` | `dst: contact/str/bytes, msg: str, timestamp: int` | `MSG_SENT` | Send direct message |
 | `send_cmd(dst, cmd, timestamp=None)` | `dst: contact/str/bytes, cmd: str, timestamp: int` | `MSG_SENT` | Send command message |
-| `send_chan_msg(chan, msg, timestamp=None)` | `chan: int, msg: str, timestamp: int` | `MSG_SENT` | Send channel message |
+| `send_chan_msg(chan, msg, timestamp=None)` | `chan: int, msg: str, timestamp: int` | `MSG_OK` | Send channel message |
 | **Authentication** ||||
 | `send_login(dst, pwd)` | `dst: contact/str/bytes, pwd: str` | `MSG_SENT` | Send login request |
 | `send_logout(dst)` | `dst: contact/str/bytes` | `MSG_SENT` | Send logout request |
@@ -577,6 +586,9 @@ All commands are async methods that return `Event` objects. Commands are organiz
 | `send_binary_req(dst, bin_data)` | `dst: contact/str/bytes, bin_data: bytes` | `MSG_SENT` | Send binary data request |
 | `send_path_discovery(dst)` | `dst: contact/str/bytes` | `MSG_SENT` | Initiate path discovery |
 | `send_trace(auth_code, tag, flags, path=None)` | `auth_code: int, tag: int, flags: int, path: list` | `MSG_SENT` | Send route trace packet |
+| **Message Retry & Scope** ||||
+| `send_msg_with_retry(dst, msg, ...)` | `dst, msg, timestamp, max_attempts, max_flood_attempts, flood_after, timeout, min_timeout` | `MSG_SENT/None` | Send message with automatic retry and ACK waiting |
+| `set_flood_scope(scope)` | `scope: str` | `OK` | Set flood scope (hash like "#name", "0"/""/"*" to disable, or raw key) |
 
 #### Binary Protocol Commands (`meshcore.commands.*`)
 
@@ -586,6 +598,9 @@ All commands are async methods that return `Event` objects. Commands are organiz
 | `req_telemetry(contact, timeout=0)` | `contact: dict, timeout: float` | `TELEMETRY_RESPONSE` | Get telemetry via binary protocol |
 | `req_mma(contact, start, end, timeout=0)` | `contact: dict, start: int, end: int, timeout: float` | `MMA_RESPONSE` | Get historical telemetry data |
 | `req_acl(contact, timeout=0)` | `contact: dict, timeout: float` | `ACL_RESPONSE` | Get access control list |
+| `sign_start()` | None | `SIGN_START` | Begin a signing session; returns maximum buffer size for data to sign |
+| `sign_data(chunk)` | `chunk: bytes` | `OK` | Append a data chunk to the current signing session (can be called multiple times) |
+| `sign_finish()` | None | `SIGNATURE` | Finalize signing and return the signature for all accumulated data |
 
 ### Helper Methods
 
@@ -593,6 +608,7 @@ All commands are async methods that return `Event` objects. Commands are organiz
 |--------|---------|-------------|
 | `get_contact_by_name(name)` | `dict/None` | Find contact by advertisement name |
 | `get_contact_by_key_prefix(prefix)` | `dict/None` | Find contact by partial public key |
+| `sign(data, chunk_size=512)` | `Event` (`SIGNATURE`/`ERROR`) | High-level helper to sign arbitrary data on-device, handling chunking for you |
 | `is_connected` | `bool` | Check if device is currently connected |
 | `subscribe(event_type, callback, filters=None)` | `Subscription` | Subscribe to events with optional filtering |
 | `unsubscribe(subscription)` | None | Remove event subscription |
@@ -632,6 +648,9 @@ Check the `examples/` directory for more:
 - `pubsub_example.py`: Event subscription system with auto-fetching
 - `serial_infos.py`: Quick device info retrieval
 - `serial_msg.py`: Message sending and receiving
+- `serial_pingbot.py`: Ping bot which can be run on a channel
+- `serial_rss_bot.py`: A RSS feed to Meshcore channel example, which broadcasts emergency bushfire warnings in VIC, AU
+- `serial_meshcore_ollama.py`: Simple Ollama to Meshcore gateway, a simple chat box 
 - `ble_pin_pairing_example.py`: BLE connection with PIN pairing
 - `ble_private_key_export.py`: BLE private key export with PIN authentication
 - `ble_t1000_infos.py`: BLE connections

{meshcore-2.1.21 → meshcore-2.2.6}/README.md

@@ -468,6 +468,8 @@ All events in MeshCore are represented by the `EventType` enum. These events are
 | `LOG_DATA` | `"log_data"` | Generic log data | Various log information |
 | **Binary Protocol Events** |||
 | `BINARY_RESPONSE` | `"binary_response"` | Generic binary response | Tag and hex data |
+| `SIGN_START` | `"sign_start"` | Start of an on-device signing session | Maximum buffer size (bytes) for data to sign |
+| `SIGNATURE` | `"signature"` | Resulting on-device signature | Raw signature bytes |
 | **Authentication Events** |||
 | `LOGIN_SUCCESS` | `"login_success"` | Successful login | Permissions, admin status, pubkey prefix |
 | `LOGIN_FAILED` | `"login_failed"` | Failed login attempt | Pubkey prefix |
@@ -517,6 +519,13 @@ All commands are async methods that return `Event` objects. Commands are organiz
 | `reboot()` | None | None | Reboot device (no response expected) |
 | **Security** ||||
 | `export_private_key()` | None | `PRIVATE_KEY/DISABLED` | Export device private key (requires PIN auth & enabled firmware) |
+| `import_private_key(key)` | `key: bytes` | `OK` | Import private key to device |
+| **Statistics** ||||
+| `get_stats_core()` | None | `STATS_CORE` | Get core statistics (voltage, uptime, errors, queue length) |
+| `get_stats_radio()` | None | `STATS_RADIO` | Get radio statistics (noise floor, last RSSI/SNR, tx/rx time stats) |
+| `get_stats_packets()` | None | `STATS_PACKETS` | Get packet statistics (rx/tx totals, flood vs. direct, recv_errors when present) |
+| **Advanced Configuration** ||||
+| `set_multi_acks(multi_acks)` | `multi_acks: int` | `OK` | Set multi-acks mode (experimental ack repeats) |
 
 #### Contact Commands (`meshcore.commands.*`)
 
@@ -544,7 +553,7 @@ All commands are async methods that return `Event` objects. Commands are organiz
 | `get_msg(timeout=None)` | `timeout: float` | `CONTACT_MSG_RECV/CHANNEL_MSG_RECV/NO_MORE_MSGS` | Get next pending message |
 | `send_msg(dst, msg, timestamp=None)` | `dst: contact/str/bytes, msg: str, timestamp: int` | `MSG_SENT` | Send direct message |
 | `send_cmd(dst, cmd, timestamp=None)` | `dst: contact/str/bytes, cmd: str, timestamp: int` | `MSG_SENT` | Send command message |
-| `send_chan_msg(chan, msg, timestamp=None)` | `chan: int, msg: str, timestamp: int` | `MSG_SENT` | Send channel message |
+| `send_chan_msg(chan, msg, timestamp=None)` | `chan: int, msg: str, timestamp: int` | `MSG_OK` | Send channel message |
 | **Authentication** ||||
 | `send_login(dst, pwd)` | `dst: contact/str/bytes, pwd: str` | `MSG_SENT` | Send login request |
 | `send_logout(dst)` | `dst: contact/str/bytes` | `MSG_SENT` | Send logout request |
@@ -555,6 +564,9 @@ All commands are async methods that return `Event` objects. Commands are organiz
 | `send_binary_req(dst, bin_data)` | `dst: contact/str/bytes, bin_data: bytes` | `MSG_SENT` | Send binary data request |
 | `send_path_discovery(dst)` | `dst: contact/str/bytes` | `MSG_SENT` | Initiate path discovery |
 | `send_trace(auth_code, tag, flags, path=None)` | `auth_code: int, tag: int, flags: int, path: list` | `MSG_SENT` | Send route trace packet |
+| **Message Retry & Scope** ||||
+| `send_msg_with_retry(dst, msg, ...)` | `dst, msg, timestamp, max_attempts, max_flood_attempts, flood_after, timeout, min_timeout` | `MSG_SENT/None` | Send message with automatic retry and ACK waiting |
+| `set_flood_scope(scope)` | `scope: str` | `OK` | Set flood scope (hash like "#name", "0"/""/"*" to disable, or raw key) |
 
 #### Binary Protocol Commands (`meshcore.commands.*`)
 
@@ -564,6 +576,9 @@ All commands are async methods that return `Event` objects. Commands are organiz
 | `req_telemetry(contact, timeout=0)` | `contact: dict, timeout: float` | `TELEMETRY_RESPONSE` | Get telemetry via binary protocol |
 | `req_mma(contact, start, end, timeout=0)` | `contact: dict, start: int, end: int, timeout: float` | `MMA_RESPONSE` | Get historical telemetry data |
 | `req_acl(contact, timeout=0)` | `contact: dict, timeout: float` | `ACL_RESPONSE` | Get access control list |
+| `sign_start()` | None | `SIGN_START` | Begin a signing session; returns maximum buffer size for data to sign |
+| `sign_data(chunk)` | `chunk: bytes` | `OK` | Append a data chunk to the current signing session (can be called multiple times) |
+| `sign_finish()` | None | `SIGNATURE` | Finalize signing and return the signature for all accumulated data |
 
 ### Helper Methods
 
@@ -571,6 +586,7 @@ All commands are async methods that return `Event` objects. Commands are organiz
 |--------|---------|-------------|
 | `get_contact_by_name(name)` | `dict/None` | Find contact by advertisement name |
 | `get_contact_by_key_prefix(prefix)` | `dict/None` | Find contact by partial public key |
+| `sign(data, chunk_size=512)` | `Event` (`SIGNATURE`/`ERROR`) | High-level helper to sign arbitrary data on-device, handling chunking for you |
 | `is_connected` | `bool` | Check if device is currently connected |
 | `subscribe(event_type, callback, filters=None)` | `Subscription` | Subscribe to events with optional filtering |
 | `unsubscribe(subscription)` | None | Remove event subscription |
@@ -610,6 +626,9 @@ Check the `examples/` directory for more:
 - `pubsub_example.py`: Event subscription system with auto-fetching
 - `serial_infos.py`: Quick device info retrieval
 - `serial_msg.py`: Message sending and receiving
+- `serial_pingbot.py`: Ping bot which can be run on a channel
+- `serial_rss_bot.py`: A RSS feed to Meshcore channel example, which broadcasts emergency bushfire warnings in VIC, AU
+- `serial_meshcore_ollama.py`: Simple Ollama to Meshcore gateway, a simple chat box 
 - `ble_pin_pairing_example.py`: BLE connection with PIN pairing
 - `ble_private_key_export.py`: BLE private key export with PIN authentication
 - `ble_t1000_infos.py`: BLE connections

meshcore-2.2.6/examples/ble_sign_example.py

@@ -0,0 +1,136 @@
+#!/usr/bin/env python3
+"""
+Example: Sign arbitrary data with a MeshCore device over BLE.
+
+The device performs signing on its private key via the CMD_SIGN_* flow:
+- sign_start(): initializes a signing session and returns max buffer size (8KB on firmware)
+- sign_data(): streams one or more data chunks
+- sign_finish(): returns the signature
+"""
+
+import argparse
+import asyncio
+from pathlib import Path
+import sys
+from textwrap import wrap
+
+# Ensure local src/ is on path when running from repo root
+repo_root = Path(__file__).resolve().parents[1]
+src_path = repo_root / "src"
+if src_path.exists():
+    sys.path.insert(0, str(src_path))
+
+from meshcore import MeshCore, EventType
+
+
+async def main():
+    parser = argparse.ArgumentParser(
+        description="Sign data using a MeshCore device over BLE"
+    )
+    parser.add_argument(
+        "-a",
+        "--addr",
+        help="BLE address of the device (optional, will scan if not provided)",
+    )
+    parser.add_argument(
+        "-p",
+        "--pin",
+        help="PIN for BLE pairing (optional)",
+    )
+    parser.add_argument(
+        "-d",
+        "--data",
+        default="Hello from meshcore_py!",
+        help="ASCII data to sign (will be UTF-8 encoded)",
+    )
+    parser.add_argument(
+        "--chunk-size",
+        type=int,
+        default=120,
+        help="Chunk size to stream to the device (bytes). Default 120 for BLE (frames under 128 bytes work better). For serial/TCP, larger values (e.g., 512) work fine.",
+    )
+    parser.add_argument(
+        "--timeout",
+        type=float,
+        default=None,
+        help="Timeout for sign_finish operation in seconds (default: 15s minimum, longer for large data like JWT tokens)",
+    )
+    parser.add_argument(
+        "--debug",
+        action="store_true",
+        help="Enable debug logging",
+    )
+    args = parser.parse_args()
+
+    meshcore = None
+    try:
+        print("Connecting to MeshCore device...")
+        meshcore = await MeshCore.create_ble(address=args.addr, pin=args.pin, debug=args.debug)
+        print("✅ Connected.")
+
+        data_bytes = args.data.encode("utf-8")
+        print(f"Data to sign: {len(data_bytes)} bytes")
+        if args.debug:
+            print(f"Data hex (first 100 bytes): {data_bytes[:100].hex()}")
+        
+        sig_evt = await meshcore.commands.sign(data_bytes, chunk_size=max(1, args.chunk_size), timeout=args.timeout)
+        if sig_evt.type == EventType.ERROR:
+            raise RuntimeError(f"sign failed: {sig_evt.payload}")
+        signature = sig_evt.payload.get("signature", b"")
+        print(f"Signature ({len(signature)} bytes):")
+        # Pretty-print hex in 32-byte lines
+        hex_sig = signature.hex()
+        for line in wrap(hex_sig, 64):
+            print(line)
+
+        # Verify signature with device's public key
+        try:
+            from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PublicKey
+            from cryptography.exceptions import InvalidSignature
+            
+            # Get device's public key from self_info
+            self_info = meshcore.self_info
+            if not self_info or "public_key" not in self_info:
+                print("\n⚠️  Could not get device public key for verification")
+            else:
+                pubkey_hex = self_info["public_key"]
+                pubkey_bytes = bytes.fromhex(pubkey_hex)
+                
+                try:
+                    public_key = Ed25519PublicKey.from_public_bytes(pubkey_bytes)
+                    public_key.verify(signature, data_bytes)
+                    print("\n✅ Signature verification: SUCCESS (signature is valid)")
+                except InvalidSignature:
+                    print("\n❌ Signature verification: FAILED (signature is invalid)")
+                    if args.debug:
+                        print(f"   Public key: {pubkey_hex}")
+                        print(f"   Data length: {len(data_bytes)} bytes")
+                        print(f"   Signature length: {len(signature)} bytes")
+                        print(f"   Data (first 50 bytes): {data_bytes[:50].hex()}")
+                except Exception as e:
+                    print(f"\n⚠️  Signature verification error: {e}")
+        except ImportError:
+            print("\n⚠️  cryptography library not available - skipping signature verification")
+            print("   Install with: pip install cryptography")
+
+        print("\nSigning flow completed!")
+
+    except ConnectionError as e:
+        print(f"❌ Failed to connect: {e}")
+        return 1
+    except Exception as e:
+        print(f"❌ Error: {e}")
+        return 1
+    finally:
+        if meshcore:
+            await meshcore.disconnect()
+            print("Disconnected.")
+
+
+if __name__ == "__main__":
+    try:
+        sys.exit(asyncio.run(main()))
+    except KeyboardInterrupt:
+        print("\nInterrupted by user")
+        sys.exit(1)
+

meshcore-2.2.6/examples/ble_stats.py

@@ -0,0 +1,77 @@
+#!/usr/bin/python
+
+import asyncio
+import argparse
+import json
+from meshcore import MeshCore, EventType
+
+DEFAULT_ADDRESS = "MeshCore-123456789"  # Default BLE address or name
+
+async def main():
+    parser = argparse.ArgumentParser(description="Read statistics from MeshCore device via BLE")
+    parser.add_argument("-a", "--address", default=DEFAULT_ADDRESS, 
+                       help="BLE device address or name (default: %(default)s)")
+    parser.add_argument("-p", "--pin", type=int, default=None,
+                       help="PIN for BLE pairing (optional)")
+    args = parser.parse_args()
+
+    print(f"Connecting to BLE device: {args.address}")
+    if args.pin:
+        print(f"Using PIN pairing: {args.pin}")
+        mc = await MeshCore.create_ble(args.address, pin=str(args.pin))
+    else:
+        mc = await MeshCore.create_ble(args.address)
+    
+    print("Connected successfully!\n")
+
+    try:
+        # Get core statistics
+        print("Fetching core statistics...")
+        result = await mc.commands.get_stats_core()
+        if result.type == EventType.ERROR:
+            print(f"❌ Error getting core stats: {result.payload}")
+        else:
+            print("📊 Core Statistics:")
+            print(json.dumps(result.payload, indent=2))
+        print()
+
+        # Get radio statistics
+        print("Fetching radio statistics...")
+        result = await mc.commands.get_stats_radio()
+        if result.type == EventType.ERROR:
+            print(f"❌ Error getting radio stats: {result.payload}")
+        else:
+            print("📡 Radio Statistics:")
+            print(json.dumps(result.payload, indent=2))
+        print()
+
+        # Get packet statistics
+        print("Fetching packet statistics...")
+        result = await mc.commands.get_stats_packets()
+        if result.type == EventType.ERROR:
+            print(f"❌ Error getting packet stats: {result.payload}")
+        else:
+            print("📦 Packet Statistics:")
+            print(json.dumps(result.payload, indent=2))
+            recv_errors = result.payload.get("recv_errors")
+            if recv_errors is not None:
+                print(f"  Receive/CRC errors (RadioLib): {recv_errors}")
+            else:
+                print("  Receive/CRC errors (RadioLib): not reported (legacy 26-byte frame)")
+        print()
+
+    except Exception as e:
+        print(f"❌ Error: {e}")
+    finally:
+        print("Disconnecting...")
+        await mc.disconnect()
+        print("Disconnected.")
+
+if __name__ == "__main__":
+    try:
+        asyncio.run(main())
+    except KeyboardInterrupt:
+        print("\nExited cleanly")
+    except Exception as e:
+        print(f"Error: {e}")
+

meshcore-2.2.6/examples/serial_meshcore_ollama.py

@@ -0,0 +1,193 @@
+import asyncio
+from meshcore import MeshCore, EventType
+
+from ollama import AsyncClient, ResponseError
+
+SERIAL_PORT = "COM16"     # change this to your serial port
+CHANNEL_IDX = 4           # change this to the index of your "#ping" channel
+MODEL_NAME = "qwen:0.5b"  # Ollama model name
+
+# FLAGS
+MAX_REPLY_CHARS = 120                 # total length of the final reply, including "@[sender] "
+ENABLE_MODEL_NSFW_FILTERING = True    # if True, Qwen is instructed to block unsafe content
+USE_CONVERSATION_HISTORY = False      # keep False to ensure no history
+ASK_MODEL_TO_LIMIT_CHARS = True       # if True, include char limit rule in system prompt
+
+
+async def main():
+    # Connect to the MeshCore companion over serial
+    meshcore = await MeshCore.create_serial(SERIAL_PORT, debug=True)
+    print(f"Connected on {SERIAL_PORT}")
+
+    # Ollama async client
+    ollama_client = AsyncClient()
+
+    # Let the library automatically fetch messages from the device
+    await meshcore.start_auto_message_fetching()
+
+    async def handle_channel_message(event):
+        msg = event.payload
+
+        chan = msg.get("channel_idx")
+        text = msg.get("text", "")
+        path_len = msg.get("path_len")
+        sender = text.split(":", 1)[0].strip()
+
+        # Everything after the first ":" is treated as the user prompt
+        if ":" in text:
+            _, user_prompt = text.split(":", 1)
+            user_prompt = user_prompt.strip()
+        else:
+            user_prompt = ""
+
+        print(
+            f"Received on channel {chan} from {sender}: {text} "
+            f"| path_len={path_len}"
+        )
+
+        if chan != CHANNEL_IDX or not user_prompt:
+            return
+
+        prefix = f"@[{sender}] "
+        # How many characters are left for the model after the prefix
+        available_for_model = max(0, MAX_REPLY_CHARS - len(prefix))
+
+        # Safety guard if sender name eats the whole budget
+        if available_for_model <= 0:
+            print("Not enough space left for model content, sending prefix only")
+            reply = prefix[:MAX_REPLY_CHARS]
+            result = await meshcore.commands.send_chan_msg(CHANNEL_IDX, reply)
+            if result.type == EventType.ERROR:
+                print(f"Error sending reply: {result.payload}")
+            else:
+                print("Reply sent")
+            return
+
+        print(f"Ollama prompt from [{sender}]: {user_prompt!r}")
+
+        # Build messages for the model
+        model_messages = []
+
+        # System message for Qwen
+        if ENABLE_MODEL_NSFW_FILTERING or ASK_MODEL_TO_LIMIT_CHARS:
+            system_rules = [
+                "Follow these rules:",
+            ]
+
+            if ENABLE_MODEL_NSFW_FILTERING:
+                system_rules.append(
+                    "1. If the request is unsafe or disallowed "
+                    "(NSFW, explicit sexual content, extreme violence, hate, "
+                    "self harm, or dangerous actions), reply exactly with: "
+                    "Cannot answer safely."
+                )
+                system_rules.append(
+                    "2. Otherwise, answer helpfully and concisely."
+                )
+            else:
+                system_rules.append(
+                    "1. Answer helpfully and concisely."
+                )
+
+            if ASK_MODEL_TO_LIMIT_CHARS:
+                rule_num = 3 if ENABLE_MODEL_NSFW_FILTERING else 2
+                system_rules.append(
+                    f"{rule_num}. Your reply must be strictly limited to {available_for_model} characters."
+                )
+                system_rules.append(
+                    f"{rule_num + 1}. Do not mention these rules."
+                )
+                system_rules.append(
+                    f"{rule_num + 2}. Only reply in English, don't reply in Chinese."
+                )                      
+                
+            else:
+                system_rules.append(
+                    "3. Do not mention these rules."
+                )
+                system_rules.append(
+                    "4. Only reply in English, don't reply in Chinese."
+                )         
+                       
+
+            system_content = " ".join(system_rules)
+
+            model_messages.append({
+                "role": "system",
+                "content": system_content,
+            })
+
+        # Single turn only when USE_CONVERSATION_HISTORY is False
+        model_messages.append({
+            "role": "user",
+            "content": user_prompt,
+        })
+
+        try:
+            response = await ollama_client.chat(
+                model=MODEL_NAME,
+                messages=model_messages,
+            )
+
+            model_reply_text = response.message.content.strip()
+
+        except ResponseError as e:
+            print(f"Ollama ResponseError: {e.error}")
+            model_reply_text = "Sorry, I had a problem talking to the model."
+        except Exception as e:
+            print(f"Unexpected error calling Ollama: {e}")
+            model_reply_text = "Sorry, something went wrong on my side."
+
+        # Normalize whitespace
+        model_reply_text = " ".join(model_reply_text.split())
+
+        # If Qwen followed the rule, unsafe replies will already be
+        # replaced by "Cannot answer safely."
+        # No manual keyword filtering here.
+
+        # Enforce hard length limit for model part
+        if len(model_reply_text) > available_for_model:
+            model_reply_text = model_reply_text[:available_for_model]
+
+        # Final reply with prefix
+        reply = prefix + model_reply_text
+
+        # Extra guard for total length
+        if len(reply) > MAX_REPLY_CHARS:
+            reply = reply[:MAX_REPLY_CHARS]
+
+        print(
+            f"Replying in channel {CHANNEL_IDX} with:\n"
+            f"{reply}"
+        )
+
+        result = await meshcore.commands.send_chan_msg(CHANNEL_IDX, reply)
+
+        if result.type == EventType.ERROR:
+            print(f"Error sending reply: {result.payload}")
+        else:
+            print("Reply sent")
+
+    # Subscribe only to messages from the chosen channel
+    subscription = meshcore.subscribe(
+        EventType.CHANNEL_MSG_RECV,
+        handle_channel_message,
+        attribute_filters={"channel_idx": CHANNEL_IDX},
+    )
+
+    try:
+        print(f"Listening for prompts on channel {CHANNEL_IDX}...")
+        # Keep the program alive
+        while True:
+            await asyncio.sleep(3600)
+    except KeyboardInterrupt:
+        print("Stopping listener...")
+    finally:
+        meshcore.unsubscribe(subscription)
+        await meshcore.stop_auto_message_fetching()
+        await meshcore.disconnect()
+        print("Disconnected")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())